private static final byte[] sSp10 = " ".getBytes();

private static final byte[] sNil10 = "\000\000\000\000\000\000\000\000\000\000".getBytes();

private static final int IS_STAR = -1;

private static final ASCIIEncoding ASCII = ASCIIEncoding.INSTANCE;

private static final USASCIIEncoding USASCII = USASCIIEncoding.INSTANCE;

private static final UTF8Encoding UTF8 = UTF8Encoding.INSTANCE;

/** Native pack type.

private static final String NATIVE_CODES = "sSiIlLjJ";

private static final String MAPPED_CODES = "sSiIqQjJ";

private static final char BE = '>' + 127; // 189, bumped up to avoid collisions with LE

private static final char LE = '<'; // 60

private static final String ENDIANESS_CODES = new String(new char[] {

's' + BE, 'S' + BE/*n*/, 'i' + BE, 'I' + BE, 'l' + BE, 'L' + BE/*N*/, 'q' + BE, 'Q' + BE, 'j' + BE, 'J' + BE,

's' + LE, 'S' + LE/*v*/, 'i' + LE, 'I' + LE, 'l' + LE, 'L' + LE/*V*/, 'q' + LE, 'Q' + LE, 'j' + LE, 'J' + LE});

/** Unpack modes

private static final int UNPACK_ARRAY = 0;

private static final int UNPACK_BLOCK = 1;

private static final int UNPACK_1 = 2;

private static final String sTooFew = "too few arguments";

private static final byte[] uu_table;

private static final byte[] b64_table;

public static final byte[] sHexDigits;

public static final int[] b64_xtable = new int[256];

private static final Converter[] converters = new Converter[512];

private static long num2quad(ThreadContext context, IRubyObject arg) {

if (arg.isNil()) return 0L;

if (arg instanceof RubyBignum bignum) return bignum.getValue().longValue();

return toLong(context, arg);

}

private static float obj2flt(ThreadContext context, IRubyObject o) {

return (float) toFloat(context.runtime, o).asDouble(context);

}

private static double obj2dbl(ThreadContext context, IRubyObject o) {

return toFloat(context.runtime, o).asDouble(context);

}

static {

uu_table =

ByteList.plain("`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_");

b64_table =

ByteList.plain("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");

sHexDigits = ByteList.plain("0123456789abcdef0123456789ABCDEFx");

// b64_xtable for decoding Base 64

for (int i = 0; i < 256; i++) {

b64_xtable[i] = -1;

}

for (int i = 0; i < 64; i++) {

b64_xtable[(int)b64_table[i]] = i;

}

// single precision, little-endian

converters['e'] = new Converter(4) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, decodeFloatLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeFloatLittleEndian(result, obj2flt(context, o));

}

};

// single precision, big-endian

converters['g'] = new Converter(4) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, decodeFloatBigEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeFloatBigEndian(result, obj2flt(context, o));

}

};

// single precision, native

Converter tmp = new Converter(4) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeFloatBigEndian(enc) : decodeFloatLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

var value = obj2flt(context, o);

if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {

encodeFloatBigEndian(result, value);

} else {

encodeFloatLittleEndian(result, value);

}

}

};

converters['F'] = tmp; // single precision, native

converters['f'] = tmp; // single precision, native

// double precision, little-endian

converters['E'] = new Converter(8) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, decodeDoubleLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeDoubleLittleEndian(result, obj2dbl(context, o));

}

};

// double precision, big-endian

converters['G'] = new Converter(8) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, decodeDoubleBigEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeDoubleBigEndian(result, obj2dbl(context, o));

}

};

// double precision, native

tmp = new Converter(8) {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFloat(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeDoubleBigEndian(enc) : decodeDoubleLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeDoubleLittleEndian(result, obj2dbl(context, o));

}

};

converters['D'] = tmp; // double precision, native

converters['d'] = tmp; // double precision, native

// signed short, little-endian

tmp = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeShortUnsignedLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeShortLittleEndian(result, overflowQuad(num2quad(context, o)));

}

};

converters['v'] = tmp;

converters['S' + LE] = tmp;

// signed short, big-endian

tmp = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeShortUnsignedBigEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

encodeShortBigEndian(result, overflowQuad(num2quad(context, o)));

}

};

converters['n'] = tmp;

converters['S' + BE] = tmp;

// signed short, native

converters['s'] = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeShortBigEndian(enc) : decodeShortLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

encodeShortByByteOrder(result, overflowQuad(num2quad(context, o))); // XXX: 0xffff0000 on BE?

}

};

// unsigned short, native

converters['S'] = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeShortUnsignedBigEndian(enc) : decodeShortUnsignedLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeShortByByteOrder(result, overflowQuad(num2quad(context, o)));

}

};

// signed short, little endian

converters['s' + LE] = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeShortLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

encodeShortLittleEndian(result, overflowQuad(num2quad(context, o))); // XXX: 0xffff0000 on BE?

}

};

// signed short, big endian

converters['s' + BE] = new QuadConverter(2, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeShortBigEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

encodeShortBigEndian(result, overflowQuad(num2quad(context, o))); // XXX: 0xffff0000 on BE?

}

};

// signed char

converters['c'] = new Converter(1, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

int c = enc.get();

return asFixnum(context, c > (char) 127 ? c-256 : c);

}

public void encode(ThreadContext context, IRubyObject o, ByteList result) {

byte c = (byte) (num2quad(context, o) & 0xff);

result.append(c);

}

};

// unsigned char

converters['C'] = new Converter(1, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, enc.get() & 0xFF);

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

byte c = o == context.nil ? 0 : (byte) (num2quad(context, o) & 0xff);

result.append(c);

}

};

// unsigned long, little-endian

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeIntUnsignedLittleEndian(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeIntLittleEndian(result, (int) toLong(context, o));

}

};

converters['V'] = tmp;

converters['L' + LE] = tmp;

converters['I' + LE] = tmp;

if (Platform.BIT_WIDTH == 32) converters['J' + LE] = tmp;

// unsigned long, big-endian

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeIntUnsignedBigEndian(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeIntBigEndian(result, (int) toLong(context, o));

}

};

converters['N'] = tmp;

converters['L' + BE] = tmp;

converters['I' + BE] = tmp;

if (Platform.BIT_WIDTH == 32) converters['J' + BE] = tmp;

// unsigned int, native

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeIntUnsignedBigEndian(enc) : decodeIntUnsignedLittleEndian(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

int s = o == context.nil ? 0 : (int) toLong(context, o);

packInt_i(result, s);

}

};

converters['I'] = tmp; // unsigned int, native

converters['L'] = tmp; // unsigned long, native

if (Platform.BIT_WIDTH == 32) converters['J'] = tmp; // unsigned long, native

// int, native

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, unpackInt_i(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

int s = o == context.nil ? 0 : (int) toLong(context, o);

packInt_i(result, s);

}

};

converters['i'] = tmp; // int, native

converters['l'] = tmp; // long, native

if (Platform.BIT_WIDTH == 32) converters['j'] = tmp; // long, native

// int, little endian

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeIntLittleEndian(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

int s = o == context.nil ? 0 : (int) toLong(context, o);

encodeIntLittleEndian(result, s);

}

};

converters['i' + LE] = tmp; // int, native

converters['l' + LE] = tmp; // long, native

if (Platform.BIT_WIDTH == 32) converters['j' + LE] = tmp; // long, native

// int, big endian

tmp = new Converter(4, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeIntBigEndian(enc));

}

public void encode(ThreadContext context, IRubyObject o, ByteList result){

int s = o == context.nil ? 0 : (int) toLong(context, o);

encodeIntBigEndian(result, s);

}

};

converters['i' + BE] = tmp; // int, native

converters['l' + BE] = tmp; // long, native

if (Platform.BIT_WIDTH == 32) converters['j' + BE] = tmp; // long, native

// 64-bit number, native (as bignum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

long l = Platform.BYTE_ORDER == Platform.BIG_ENDIAN ? decodeLongBigEndian(enc) : decodeLongLittleEndian(enc);

return RubyBignum.bignorm(context.runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongByByteOrder(result, num2quad(context, o));

}

};

converters['Q'] = tmp;

if (Platform.BIT_WIDTH == 64) converters['J'] = tmp;

// 64-bit number, little endian (as bignum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

long l = decodeLongLittleEndian(enc);

return RubyBignum.bignorm(context.runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongLittleEndian(result, num2quad(context, o));

}

};

converters['Q' + LE] = tmp;

if (Platform.BIT_WIDTH == 64) converters['J' + LE] = tmp;

// 64-bit number, big endian (as bignum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

long l = decodeLongBigEndian(enc);

return RubyBignum.bignorm(context.runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongBigEndian(result, num2quad(context, o));

}

};

converters['Q' + BE] = tmp;

if (Platform.BIT_WIDTH == 64) converters['J' + BE] = tmp;

// 64-bit number, native (as fixnum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?

decodeLongBigEndian(enc) : decodeLongLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongByByteOrder(result, num2quad(context, o));

}

};

converters['q'] = tmp;

if (Platform.BIT_WIDTH == 64) converters['j'] = tmp;

// 64-bit number, little-endian (as fixnum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeLongLittleEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongLittleEndian(result, num2quad(context, o));

}

};

converters['q' + LE] = tmp;

if (Platform.BIT_WIDTH == 64) converters['j' + LE] = tmp;

// 64-bit number, big-endian (as fixnum)

tmp = new QuadConverter(8, "Integer") {

public IRubyObject decode(ThreadContext context, ByteBuffer enc) {

return asFixnum(context, decodeLongBigEndian(enc));

}

@Override

public void encode(ThreadContext context, IRubyObject o, ByteList result){

encodeLongBigEndian(result, num2quad(context, o));

}

};

converters['q' + BE] = tmp;

if (Platform.BIT_WIDTH == 64) converters['j' + BE] = tmp;

// pointer; we can't provide a real pointer, so we just use identity hashcode

tmp = new QuadConverter(8) {

@Override

public IRubyObject decode(ThreadContext context, ByteBuffer format) {

return context.nil;

}

@Override

public void encode(ThreadContext context, IRubyObject from, ByteList result) {

if (from.isNil()) {

encodeLongBigEndian(result, 0);

} else {

encodeLongBigEndian(result, System.identityHashCode(from));

}

}

};

converters['p'] = tmp;

// pointer; we can't provide a real pointer, so we just use identity hashcode

tmp = new QuadConverter(8) {

@Override

public IRubyObject decode(ThreadContext context, ByteBuffer format) {

return context.nil;

}

@Override

public void encode(ThreadContext context, IRubyObject from, ByteList result) {

if (from.isNil()) {

encodeLongBigEndian(result, 0);

} else {

encodeLongBigEndian(result, System.identityHashCode(from.convertToString()));

}

}

};

converters['P'] = tmp;

}

public static int unpackInt_i(ByteBuffer enc) {

int value;

if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {

value = decodeIntBigEndian(enc);

} else {

value = decodeIntLittleEndian(enc);

}

return value;

}

public static ByteList packInt_i(ByteList result, int s) {

if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {

encodeIntBigEndian(result, s);

} else {

encodeIntLittleEndian(result, s);

}

return result;

}

private static void encodeUM(ThreadContext context, ByteList lCurElemString, int occurrences, boolean ignoreStar, char type, ByteList result) {

if (occurrences == 0 && type == 'm' && !ignoreStar) {

encodes(context, result, lCurElemString.getUnsafeBytes(),

lCurElemString.getBegin(), lCurElemString.length(),

lCurElemString.length(), (byte) type, false);

return;

}

occurrences = occurrences <= 2 ? 45 : occurrences / 3 * 3;

if (lCurElemString.isEmpty()) return;

byte[] charsToEncode = lCurElemString.getUnsafeBytes();

for (int i = 0; i < lCurElemString.length(); i += occurrences) {

encodes(context, result, charsToEncode,

i + lCurElemString.getBegin(), lCurElemString.length() - i,

occurrences, (byte)type, true);

}

}

/**

private static ByteList encodes(ThreadContext context, ByteList io2Append,byte[] charsToEncode, int startIndex,

int length, int charCount, byte encodingType, boolean tailLf) {

charCount = Math.min(charCount, length);

io2Append.ensure(charCount * 4 / 3 + 6);

int i = startIndex;

byte[] lTranslationTable = encodingType == 'u' ? uu_table : b64_table;

byte lPadding;

if (encodingType == 'u') {

if (charCount >= lTranslationTable.length) {

throw argumentError(context, charCount

+ " is not a correct value for the number of bytes per line in a u directive. Correct values range from 0 to "

+ lTranslationTable.length);

}

io2Append.append(lTranslationTable[charCount]);

lPadding = '`';

} else {

lPadding = '=';

}

while (charCount >= 3) {

byte lCurChar = charsToEncode[i++];

byte lNextChar = charsToEncode[i++];

byte lNextNextChar = charsToEncode[i++];

io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);

io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | ((lNextChar >>> 4) & 017))]);

io2Append.append(lTranslationTable[077 & (((lNextChar << 2) & 074) | ((lNextNextChar >>> 6) & 03))]);

io2Append.append(lTranslationTable[077 & lNextNextChar]);

charCount -= 3;

}

if (charCount == 2) {

byte lCurChar = charsToEncode[i++];

byte lNextChar = charsToEncode[i++];

io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);

io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | ((lNextChar >> 4) & 017))]);

io2Append.append(lTranslationTable[077 & (((lNextChar << 2) & 074) | (('\0' >> 6) & 03))]);

io2Append.append(lPadding);

} else if (charCount == 1) {

byte lCurChar = charsToEncode[i++];

io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);

io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | (('\0' >>> 4) & 017))]);

io2Append.append(lPadding);

io2Append.append(lPadding);

}

if (tailLf) {

io2Append.append('\n');

}

return io2Append;

}

public static RubyArray unpack(ThreadContext context, ByteList encodedString, ByteList formatString) {

return unpackWithBlock(context, RubyString.newStringLight(context.runtime, encodedString), formatString, Block.NULL_BLOCK);

}

/**

public static RubyArray unpack(ThreadContext context, RubyString encoded, ByteList formatString) {

return unpackWithBlock(context, encoded, formatString, Block.NULL_BLOCK);

}

/**

public static RubyArray unpackWithBlock(ThreadContext context, RubyString encoded, ByteList formatString, Block block) {

return (RubyArray) unpackInternal(context, encoded, formatString, block.isGiven() ? UNPACK_BLOCK : UNPACK_ARRAY, 0, block);

}

public static RubyArray unpackWithBlock(ThreadContext context, RubyString encoded, ByteList formatString, long offset, Block block) {

return (RubyArray) unpackInternal(context, encoded, formatString, block.isGiven() ? UNPACK_BLOCK : UNPACK_ARRAY, offset, block);

}

private static RubyString unpackBase46Strict(ThreadContext context, ByteList input) {

int index = 0; // current index of out

int s = -1;

int a = -1;

int b = -1;

int c = 0;

byte[] buf = input.unsafeBytes();

int begin = input.begin();

int length = input.realSize();

int end = begin + length;

if (length % 4 != 0) throw argumentError(context, "invalid base64");

int p = begin;

byte[] out = new byte[3 * ((length + 3) / 4)];

while (p < end && s != '=') {

// obtain a

s = buf[p++];

a = b64_xtable[s];

if (a == -1) throw argumentError(context, "invalid base64");

// obtain b

s = buf[p++];

b = b64_xtable[s];

if (b == -1) throw argumentError(context, "invalid base64");

// obtain c

s = buf[p++];

c = b64_xtable[s];

if (s == '=') {

if (buf[p++] != '=') throw argumentError(context, "invalid base64");

break;

}

if (c == -1) throw argumentError(context, "invalid base64");

// obtain d

s = buf[p++];

int d = b64_xtable[s];

if (s == '=') break;

if (d == -1) throw argumentError(context, "invalid base64");

// calculate based on a, b, c and d

out[index++] = (byte) (a << 2 | b >> 4);

out[index++] = (byte) (b << 4 | c >> 2);

out[index++] = (byte) (c << 6 | d);

}

if (p < end) throw argumentError(context, "invalid base64");

if (a != -1 && b != -1) {

if (c == -1 && s == '=') {

if ((b & 15) > 0) throw argumentError(context, "invalid base64");

out[index++] = (byte)((a << 2 | b >> 4) & 255);

} else if(c != -1 && s == '=') {

if ((c & 3) > 0) throw argumentError(context, "invalid base64");

out[index++] = (byte)((a << 2 | b >> 4) & 255);

out[index++] = (byte)((b << 4 | c >> 2) & 255);

}

}

return newString(context, new ByteList(out, 0, index));

}

public static IRubyObject unpack1WithBlock(ThreadContext context, RubyString encoded, ByteList formatString, Block block) {

return unpack1WithBlock(context, encoded, formatString, 0, block);

}

public static IRubyObject unpack1WithBlock(ThreadContext context, RubyString encoded, ByteList formatString, long offset, Block block) {

int formatLength = formatString.realSize();

// Strict m0 is commmonly used in cookie handling so it has a fast path.

if (formatLength >= 1) {

byte first = (byte) (formatString.get(0) & 0xff);

if (first == 'm') {

if (formatLength == 2) {

byte second = (byte) (formatString.get(1) & 0xff);

if (second == '0') return unpackBase46Strict(context, encoded.getByteList());

}

}

}

return unpackInternal(context, encoded, formatString, UNPACK_1, offset, block);

}

private static IRubyObject unpackInternal(ThreadContext context, RubyString encoded, ByteList formatString, int mode, long offset, Block block) {

final var result = mode == UNPACK_BLOCK || mode == UNPACK_1 ? null : newArray(context);

final ByteList encodedString = encoded.getByteList();

int len = encodedString.realSize();

int beg = encodedString.begin();

if (offset < 0) throw argumentError(context, "offset can't be negative");

if (offset > 0) {

if (offset > len) throw argumentError(context, "offset outside of string");

beg += offset;

len -= offset;

}

// FIXME: potentially could just use ByteList here?

ByteBuffer format = ByteBuffer.wrap(formatString.getUnsafeBytes(), formatString.begin(), formatString.length());

ByteBuffer encode = ByteBuffer.wrap(encodedString.getUnsafeBytes(), beg, len);

int next = getDirective(context, "unpack", formatString, format);

IRubyObject value = null; // UNPACK_1

mainLoop: while (next != 0) {

int type = next;

next = getDirective(context, "unpack", formatString, format);

if (isSpace(type)) continue;

if (type == '#') {

type = skipToEOL(format);

if (type == 0) break; // exit on EOF

next = getDirective(context, "unpack", formatString, format);

continue; // continue after newline

}

// Next indicates to decode using native encoding format

if (next == '_' || next == '!') {

int index = NATIVE_CODES.indexOf(type);

if (index == -1) {

throw argumentError(context, "'" + next + "' allowed only after types " + NATIVE_CODES);