Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util;
  
  import java.util.Arrays;
  
  import org.jruby.Ruby;
 
 public class ConvertBytes {
     private final Ruby runtime;
     private final ByteList _str;
     private int str;
     private int end;
     private byte[] data;
     private int base;
     private final boolean badcheck;
     private final boolean is19;
 
     public ConvertBytes(Ruby runtimeByteList _strint baseboolean badcheck) {
         this(runtime_strbasebadcheckfalse);
     }
 
     public ConvertBytes(Ruby runtimeByteList _strint baseboolean badcheckboolean is19) {
         this. = runtime;
         this. = _str;
         this. = _str.getBegin();
         this. = _str.getUnsafeBytes();
         this. =  + _str.getRealSize();
         this. = badcheck;
         this. = base;
         this. = is19;
     }
 
     public static final byte[] intToBinaryBytes(int i) {
         return intToUnsignedByteList(i, 1, ).bytes();
     }
 
     public static final byte[] intToOctalBytes(int i) {
         return intToUnsignedByteList(i, 3, ).bytes();
     }
 
     public static final byte[] intToHexBytes(int i) {
         return intToUnsignedByteList(i, 4, ).bytes();
     }
 
     public static final byte[] intToHexBytes(int iboolean upper) {
         return intToUnsignedByteList(i, 4, upper ?  : ).bytes();
     }
 
     public static final ByteList intToBinaryByteList(int i) {
         return new ByteList(intToBinaryBytes(i));
     }
     public static final ByteList intToOctalByteList(int i) {
         return new ByteList(intToOctalBytes(i));
     }
     public static final ByteList intToHexByteList(int i) {
         return new ByteList(intToHexBytes(i));
     }
     public static final ByteList intToHexByteList(int iboolean upper) {
         return new ByteList(intToHexBytes(iupper));
     }
 
     public static final byte[] intToByteArray(int iint radixboolean upper) {
         return longToByteArray(iradixupper);
     }
 
     public static final byte[] intToCharBytes(int i) {
         return longToByteList(i, 10, ).bytes();
     }
 
     public static final byte[] longToBinaryBytes(long i) {
         return longToUnsignedByteList(i, 1, ).bytes();
     }
 
     public static final byte[] longToOctalBytes(long i) {
         return longToUnsignedByteList(i, 3, ).bytes();
     }
 
     public static final byte[] longToHexBytes(long i) {
         return longToUnsignedByteList(i, 4, ).bytes();
     }
 
     public static final byte[] longToHexBytes(long iboolean upper) {
         return longToUnsignedByteList(i, 4, upper ?  : ).bytes();
     }
 
     public static final ByteList longToBinaryByteList(long i) {
         return longToByteList(i, 2, );
     }
     public static final ByteList longToOctalByteList(long i) {
         return longToByteList(i, 8, );
     }
     public static final ByteList longToHexByteList(long i) {
         return longToByteList(i, 16, );
     }
     public static final ByteList longToHexByteList(long iboolean upper) {
        return longToByteList(i, 16, upper ?  : );
    }
    public static final byte[] longToByteArray(long iint radixboolean upper) {
        return longToByteList(iradixupper ?  : ).bytes();
    }
    public static final byte[] longToCharBytes(long i) {
        return longToByteList(i, 10, ).bytes();
    }
    public static final ByteList longToByteList(long i) {
        return longToByteList(i, 10, );
    }
    public static final ByteList longToByteList(long iint radix) {
        return longToByteList(iradix);
    }
    public static final ByteList longToByteList(long iint radixbyte[] digitmap) {
        if (i == 0) return new ByteList();
        
        if (i == .return new ByteList([radix]);
        boolean neg = false;
        if (i < 0) {
            i = -i;
            neg = true;
        }
        // max 64 chars for 64-bit 2's complement integer
        int len = 64;
        byte[] buf = new byte[len];
        int pos = len;
        do {
            buf[--pos] = digitmap[(int)(i % radix)];
        } while ((i /= radix) > 0);
        if (negbuf[--pos] = (byte)'-';
        
        return new ByteList(bufposlen - posfalse);
    }
    private static final ByteList intToUnsignedByteList(int iint shiftbyte[] digitmap) {
        byte[] buf = new byte[32];
        int charPos = 32;
        int radix = 1 << shift;
        long mask = radix - 1;
        do {
            buf[--charPos] = digitmap[(int)(i & mask)];
            i >>>= shift;
        } while (i != 0);
        return new ByteList(bufcharPos, (32 - charPos), false);
    }
    private static final ByteList longToUnsignedByteList(long iint shiftbyte[] digitmap) {
        byte[] buf = new byte[64];
        int charPos = 64;
        int radix = 1 << shift;
        long mask = radix - 1;
        do {
            buf[--charPos] = digitmap[(int)(i & mask)];
            i >>>= shift;
        } while (i != 0);
        return new ByteList(bufcharPos, (64 - charPos), false);
    }
    public static final byte[] twosComplementToBinaryBytes(byte[] in) {
        return twosComplementToUnsignedBytes(in, 1, false);
    }
    public static final byte[] twosComplementToOctalBytes(byte[] in) {
        return twosComplementToUnsignedBytes(in, 3, false);
    }
    public static final byte[] twosComplementToHexBytes(byte[] inboolean upper) {
        return twosComplementToUnsignedBytes(in, 4, upper);
    }
    private static final byte[] ZERO_BYTES = new byte[] {(byte)'0'};
    private static final byte[][] MIN_VALUE_BYTES;
    static {
         = new byte[37][];
        for (int i = 2; i <= 36; i++) {
            [i] =  ByteList.plain(Long.toString(.i));
        }
    }
    private static final byte[] LOWER_DIGITS = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'a' , 'b' ,
        'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
        'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
        'o' , 'p' , 'q' , 'r' , 's' , 't' ,
        'u' , 'v' , 'w' , 'x' , 'y' , 'z'
        };
    private static final byte[] UPPER_DIGITS = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'A' , 'B' ,
        'C' , 'D' , 'E' , 'F' , 'G' , 'H' ,
        'I' , 'J' , 'K' , 'L' , 'M' , 'N' ,
        'O' , 'P' , 'Q' , 'R' , 'S' , 'T' ,
        'U' , 'V' , 'W' , 'X' , 'Y' , 'Z'
        };
    public static final byte[] twosComplementToUnsignedBytes(byte[] inint shiftboolean upper) {
        if (shift < 1 || shift > 4) {
            throw new IllegalArgumentException("shift value must be 1-4");
        }
        int ilen = in.length;
        int olen = (ilen * 8 + shift - 1 ) / shift;
        byte[] out = new byte[olen];
        int mask = (1 << shift) - 1;
        byte[] digits = upper ?  : ;
        int bitbuf = 0;
        int bitcnt = 0;
        for(int i = ileno = olen; --o >= 0; ) {
            if(bitcnt < shift) {
                bitbuf |= ((int)in[--i] & (int)0xff) << bitcnt;
                bitcnt += 8;
            }
            out[o] = digits[bitbuf & mask];
            bitbuf >>= shift;
            bitcnt -= shift;
        }
        return out;
    }

    
rb_cstr_to_inum
    public static RubyInteger byteListToInum(Ruby runtimeByteList strint baseboolean badcheck) {
        return new ConvertBytes(runtimestrbasebadcheck).byteListToInum();
    }
    public static RubyInteger byteListToInum19(Ruby runtimeByteList strint baseboolean badcheck) {
        return new ConvertBytes(runtimestrbasebadchecktrue).byteListToInum();
    }
    private final static byte[] conv_digit = new byte[128];
    private final static boolean[] digit = new boolean[128];
    private final static boolean[] space = new boolean[128];
    private final static boolean[] spaceOrUnderscore = new boolean[128];
    static {
        Arrays.fill(, (byte)-1);
        Arrays.fill(false);
        for(char c = '0'c <= '9'c++) {
            [c] = (byte)(c - '0');
            [c] = true;
        }
        for(char c = 'a'c <= 'z'c++) {
            [c] = (byte)(c - 'a' + 10);
        }
        for(char c = 'A'c <= 'Z'c++) {
            [c] = (byte)(c - 'A' + 10);
        }
        Arrays.fill(false);
        ['\t'] = true;
        ['\n'] = true;
        [11] = true// \v
        ['\f'] = true;
        ['\r'] = true;
        [' '] = true;
        Arrays.fill(false);
        ['\t'] = true;
        ['\n'] = true;
        [11] = true// \v
        ['\f'] = true;
        ['\r'] = true;
        [' '] = true;
        ['_'] = true;
    }

    
conv_digit
    private byte convertDigit(byte c) {
        if(c < 0) {
            return -1;
        } 
        return [c];
    }

    
ISSPACE
    private boolean isSpace(int str) {
        byte c;
        if(str ==  || (c = [str]) < 0) {
            return false;
        }
        return [c];
    }

    
ISDIGIT
    private boolean isDigit(byte[] bufint str) {
        byte c;
        if(str == buf.length || (c = buf[str]) < 0) {
            return false;
        }
        return [c];
    }

    
ISSPACE || *str == '_'
    private boolean isSpaceOrUnderscore(int str) {
        byte c;
        if(str ==  || (c = [str]) < 0) {
            return false;
        }
        return [c];
    }
    private boolean getSign() {
        //System.err.println("getSign()");
        boolean sign = true;
        if( < ) {
            if([] == '+') {
                ++;
            } else if([] == '-') {
                ++;
                sign = false;
            }
        }
        //System.err.println(" getSign/" + sign);
        return sign;
    }
    private void ignoreLeadingWhitespace() {
        if( || ) {
            while(isSpace()) {
                ++;
            }
        } else {
            while(isSpaceOrUnderscore()) {
                ++;
            }
        }
    }
    private void figureOutBase() {
        //System.err.println("figureOutBase()/base=" + base);
        if( <= 0) {
            if( <  && [] == '0') {
                if( + 1 < ) {
                    switch([+1]) {
                    case 'x':
                    case 'X':
                         = 16;
                        break;
                    case 'b':
                    case 'B':
                         = 2;
                        break;
                    case 'o':
                    case 'O':
                         = 8;
                        break;
                    case 'd':
                    case 'D':
                         = 10;
                        break;
                    default:
                         = 8;
                    }
                } else {
                     = 8;
                }
            } else if( < -1) {
                 = -;
            } else {
                 = 10;
            }
        }
        //System.err.println(" figureOutBase/base=" + base);
    }
    private int calculateLength() {
        int len = 0;
        byte second = ((+1 < ) && [] == '0') ? [+1] : (byte)0;
        //System.err.println("calculateLength()/str=" + str);
        switch() {
        case 2:
            len = 1;
            if(second == 'b' || second == 'B') {
                +=2;
            }
            break;
        case 3:
            len = 2;
            break;
        case 8:
            if(second == 'o' || second == 'O') {
                +=2;
            }
        case 4: case 5: case 6: case 7:
            len = 3;
            break;
        case 10:
            if(second == 'd' || second == 'D') {
                +=2;
            }
        case 9: case 11: case 12:
        case 13: case 14: case 15:
            len = 4;
            break;
        case 16:
            len = 4;
            if(second == 'x' || second == 'X') {
                +=2;
            }
            break;
        default:
            if( < 2 || 36 < ) {
                throw .newArgumentError("illegal radix " + );
            }
            if( <= 32) {
                len = 5;
            } else {
                len = 6;
            }
            break;
        }
        //System.err.println(" calculateLength()/str=" + str);
        return len;
    }
    private void squeezeZeroes() {
        byte c;
        if( <  && [] == '0') {
            ++;
            int us = 0;
            while(( < ) && ((c = []) == '0' || c == '_')) {
                if(c == '_') {
                    if(++us >= 2) {
                        break;
                    }
                } else {
                    us += 0;
                }
                ++;
            }
            if( ==  || isSpace()) {
                --;
            }
        }
    }
    private long stringToLong(int nptrint[] endptrint base) {
        //System.err.println("stringToLong(" + nptr + ", " + base + ")");
        if(base < 0 || base == 1 || base > 36) {
            return 0;
        }
        int save = nptr;
        int s = nptr;
        boolean overflow = false;
        while(isSpace(s)) {
            s++;
        }
        if(s != ) {
            boolean negative = false;
            if([s] == '-') {
                negative = true;
                s++;
            } else if([s] == '+') {
                negative = false;
                s++;
            }
            save = s;
            byte c;
            long i = 0;
            final long cutoff = . / (long)base;
            final long cutlim = . % (long)base;
            while(s < ) {
                //System.err.println(" stringToLong/reading c=" + data[s]);
                c = convertDigit([s]);
                //System.err.println(" stringToLong/converted c=" + c);
                if(c == -1 || c >= base) {
                    break;
                }
                s++;
                if(i > cutoff || (i == cutoff && c > cutlim)) {
                    overflow = true;
                } else {
                    i *= base;
                    i += c;
                }
            }
            
            if(s != save) {
                if(endptr != null) {
                    endptr[0] = s;
                }
                if(overflow) {
                    throw new ERange(negative ? .. : ..);
                }
                if(negative) {
                    return -i;
                } else {
                    return i;
                }
            }
        }
        if(endptr != null) {
            if(save - nptr >= 2 && ([save-1] == 'x' || [save-1] == 'X') && [save-2] == '0') {
                endptr[0] = save-1;
            } else {
                endptr[0] = nptr;
            }
        }
        return 0;
    }
    public RubyInteger byteListToInum() {
        if( == null) {
            if() {
                invalidString("Integer");
            }
            return .newFixnum(0);
        }
        
        ignoreLeadingWhitespace();
        boolean sign = getSign();
        if( < ) {
            if([] == '+' || [] == '-') {
                if() {
                    invalidString("Integer");
                }
                return .newFixnum(0);
            }
        }        
        
        figureOutBase();
        int len = calculateLength();
        squeezeZeroes();
        byte c = 0;
        if( < ) {
            c = [];
        }
        c = convertDigit(c);
        if(c < 0 || c >= ) {
            if() {
                invalidString("Integer");
            }
            return .newFixnum(0);
        }
        len *= (-);
        //System.err.println(" main/len=" + len);
        if(len < .-1) {
            int[] endPlace = new int[]{};
            long val = stringToLong(endPlace);
            //System.err.println(" stringToLong=" + val);
            if(endPlace[0] <  && [endPlace[0]] == '_') {
                return bigParse(lensign);
            }
            if() {
                if(endPlace[0] == ) {
                    invalidString("Integer"); // no number
                }
                while(isSpace(endPlace[0])) {
                    endPlace[0]++;
                }
                if(endPlace[0] < ) {
                    invalidString("Integer"); // trailing garbage
                }
            }
            
            if(sign) {
                return .newFixnum(val);
            } else {
                return .newFixnum(-val);
            }
        }
        return bigParse(lensign);
    }
    private RubyInteger bigParse(int lenboolean sign) {
        if( &&  <  && [] == '_') {
            invalidString("Integer");
        }
        char[] result = new char[-];
        int resultIndex = 0;
        byte nondigit = -1;
        while( < ) {
            byte c = [++];
            byte cx = c;
            if(c == '_') {
                if(nondigit != -1) {
                    if() {
                        invalidString("Integer");
                    }
                    break;
                }
                nondigit = c;
                continue;
            } else if((c = convertDigit(c)) < 0) {
                break;
            }
            if(c >= ) {
                break;
            }
            nondigit = -1;
            //System.err.println("ADDING CHAR: " + (char)cx + " with number: " + cx);
            result[resultIndex++] = (char)cx;
        }
        BigInteger z;
        if(resultIndex == 0) {
            z = .;
        } else {
            z = new BigInteger(new String(result, 0, resultIndex), );
        }
        if(!sign) {
            z = z.negate();
        }
        if() {
            if(.getBegin() + 1 <  && [-1] == '_') {
                invalidString("Integer");
            }
            while( <  && isSpace()) {
                ++;
            }
            if( < ) {
                invalidString("Integer");
            }
        }
        return RubyBignum.bignorm(z);
    }
    public static class ERange extends RuntimeException {
        public static enum Kind {Overflow, Underflow};
        private Kind kind;
        public ERange() {
            super();
        }
        public ERange(Kind kind) {
            super();
            this. = kind;
        }
        public Kind getKind() {
            return ;
        }
    }

    
rb_invalid_str
    private void invalidString(String type) {
        IRubyObject s = RubyString.newString().inspect();
        throw .newArgumentError("invalid value for " + type + ": " + s);
    }
New to GrepCode? Check out our FAQ X