package org.jcodings.transcode;
import org.jcodings.Ptr;
public class Transcoding implements TranscodingInstruction {
public Transcoding(Transcoder transcoder, int flags) {
this.transcoder = transcoder;
this.flags = flags;
this.resumePosition = START;
this.recognizedLength = 0;
this.readAgainLength = 0;
this.writeBuffLen = 0;
this.writeBuffOff = 0;
this.readBuf = new byte[transcoder.maxInput];
this.writeBuf = new byte[transcoder.maxOutput];
this.state = new byte[transcoder.stateSize];
transcoder.stateInit(state);
}
public final Transcoder transcoder;
private int flags;
private int resumePosition;
private int nextTable;
private int nextInfo;
private byte nextByte;
private int outputIndex;
int recognizedLength, readAgainLength;
final byte[] readBuf;
private int writeBuffOff, writeBuffLen;
private final byte[] writeBuf;
final byte[] state;
private EConvResult suspendResult;
void close() {
transcoder.stateFinish(state);
}
private int charStart;
private byte[] charStartBytes;
@Override
public String toString() {
return "Transcoding for transcoder " + transcoder.toString();
}
int charStart() {
if (recognizedLength > inCharStart - inPos.p) {
System.arraycopy(inBytes, inCharStart, readBuf, recognizedLength, inP - inCharStart);
charStart = 0;
charStartBytes = readBuf;
} else {
charStart = inCharStart - recognizedLength;
charStartBytes = inBytes;
}
return recognizedLength + (inP - inCharStart);
}
EConvResult convert(byte[] in, Ptr inPtr, int inStop, byte[] out, Ptr outPtr, int outStop, int flags) {
return transcodeRestartable(in, inPtr, inStop, out, outPtr, outStop, flags);
}
private EConvResult transcodeRestartable(byte[] in, Ptr inStart, int inStop, byte[] out, Ptr outStart, int outStop, int opt) {
if (readAgainLength != 0) {
byte[] readAgainBuf = new byte[readAgainLength];
Ptr readAgainPos = new Ptr(0);
int readAgainStop = readAgainLength;
System.arraycopy(readBuf, recognizedLength, readAgainBuf, readAgainPos.p, readAgainLength);
readAgainLength = 0;
System.arraycopy(readAgainBuf, 0, TRANSCODING_READBUF(this), recognizedLength, readAgainLength);
readAgainLength = 0;
EConvResult res = transcodeRestartable0(readAgainBuf, readAgainPos, out, outStart, readAgainStop, outStop, opt | EConv.PARTIAL_INPUT);
if (!res.isSourceBufferEmpty()) {
System.arraycopy(readAgainBuf, readAgainPos.p, readBuf, recognizedLength + readAgainLength, readAgainStop - readAgainPos.p);
readAgainLength += readAgainStop - readAgainPos.p;
}
}
return transcodeRestartable0(in, inStart, out, outStart, inStop, outStop, opt);
}
private int inCharStart;
private byte[] inBytes;
private int inP;
private Ptr inPos;
private static int STR1_LENGTH(byte[] bytes, int byteaddr) {
return bytes[byteaddr] + 4;
}
private static int STR1_BYTEINDEX(int w) {
return w >>> 6;
}
private EConvResult transcodeRestartable0(final byte[] in_bytes, Ptr in_pos, final byte[] out_bytes, Ptr out_pos, int in_stop, int out_stop, int opt) {
Transcoder tr = transcoder;
int unitlen = tr.inputUnitLength;
int readagain_len = 0;
int inchar_start = in_pos.p;
int in_p = inchar_start;
int out_p = out_pos.p;
int[] char_len = null;
byte[][] outByteParam = null;
int ip = resumePosition;
MACHINE: while (true) {
switch (ip) {
case START:
inchar_start = in_p;
recognizedLength = 0;
nextTable = tr.treeStart;
if (SUSPEND == SUSPEND_AFTER_OUTPUT(this, opt, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_AFTER_OUTPUT)) return suspendResult;
case RESUME_AFTER_OUTPUT:
if (in_stop <= in_p) {
if ((opt & EConvFlags.PARTIAL_INPUT) == 0) {
ip = CLEANUP;
continue;
}
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.SourceBufferEmpty, START);
return suspendResult;
}
case NEXTBYTE:
nextByte = in_bytes[in_p++];
case FOLLOW_BYTE:
if ((nextByte & 0xFF) < BL_MIN_BYTE(this) || BL_MAX_BYTE(this) < (nextByte & 0xFF)) {
nextInfo = INVALID;
} else {
nextInfo = BL_ACTION(this, nextByte);
}
case FOLLOW_INFO:
switch (nextInfo & 0x1F) {
case NOMAP:
int p = inchar_start;
writeBuffOff = 0;
while (p < in_p) {
writeBuf[writeBuffOff++] = in_bytes[p++];
}
writeBuffLen = writeBuffOff;
writeBuffOff = 0;
ip = NOMAP_TRANSFER;
continue;
case 0x00: case 0x04: case 0x08: case 0x0C: case 0x10: case 0x14: case 0x18: case 0x1C:
if (SUSPEND == SUSPEND_AFTER_OUTPUT(this, opt, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, SELECT_TABLE)) return suspendResult;
ip = SELECT_TABLE;
continue;
case ZERObt:
ip = START;
continue;
case ONEbt:
ip = ONE_BYTE_1;
continue;
case TWObt:
ip = TWO_BYTE_1;
continue;
case THREEbt:
ip = FOUR_BYTE_1;
continue;
case FOURbt:
ip = FOUR_BYTE_0;
continue;
case GB4bt:
ip = GB_FOUR_BYTE_0;
continue;
case STR1:
outputIndex = 0;
ip = STRING;
continue;
case FUNii:
nextInfo = tr.infoToInfo(state, nextInfo);
ip = FOLLOW_INFO;
continue;
case FUNsi:
{
int char_start;
char_len = PREPARE_CHAR_LEN(char_len);
outByteParam = PREPARE_OUT_BYTES(outByteParam);
char_start = transcode_char_start(in_bytes, in_pos.p, inchar_start, in_p, char_len, outByteParam);
nextInfo = tr.startToInfo(state, outByteParam[0], char_start, char_len[0]);
ip = FOLLOW_INFO;
continue;
}
case FUNio:
ip = CALL_FUN_IO;
continue;
case FUNso:
ip = RESUME_CALL_FUN_SO;
continue;
case FUNsio:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_CALL_FUN_SIO)) return suspendResult;
ip = CALL_FUN_SIO;
continue;
case INVALID:
if (recognizedLength + (in_p - inchar_start) <= unitlen) {
if (recognizedLength + (in_p - inchar_start) < unitlen) {
if (SUSPEND == SUSPEND_AFTER_OUTPUT(this, opt, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, READ_MORE)) return suspendResult;
}
ip = READ_MORE;
continue;
} else {
int invalid_len;
int discard_len;
invalid_len = recognizedLength + (in_p - inchar_start);
discard_len = ((invalid_len - 1) / unitlen) * unitlen;
readagain_len = invalid_len - discard_len;
ip = REPORT_INVALID;
continue;
}
case UNDEF:
ip = REPORT_UNDEF;
continue;
default:
throw new RuntimeException("unknown transcoding instruction");
}
case READ_MORE:
while ((opt & EConvFlags.PARTIAL_INPUT) != 0 && recognizedLength + (in_stop - inchar_start) < unitlen) {
in_p = in_stop;
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.SourceBufferEmpty, READ_MORE);
return suspendResult;
}
if (recognizedLength + (in_stop - inchar_start) <= unitlen) {
in_p = in_stop;
} else {
in_p = inchar_start + (unitlen - recognizedLength);
}
ip = REPORT_INVALID;
continue;
case RESUME_CALL_FUN_SIO:
while (out_stop - out_p < 1) {
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.DestinationBufferFull, RESUME_CALL_FUN_SIO);
return suspendResult;
}
case CALL_FUN_SIO:
{
int char_start;
char_len = PREPARE_CHAR_LEN(char_len);
outByteParam = PREPARE_OUT_BYTES(outByteParam);
if (tr.maxOutput <= out_stop - out_p) {
char_start = transcode_char_start(in_bytes, in_pos.p, inchar_start, in_p, char_len, outByteParam);
out_p += tr.startInfoToOutput(state, outByteParam[0], char_start, char_len[0], nextInfo, out_bytes, out_p, out_stop - out_p);
ip = START;
continue;
} else {
char_start = transcode_char_start(in_bytes, in_pos.p, inchar_start, in_p, char_len, outByteParam);
writeBuffLen = tr.startInfoToOutput(state, outByteParam[0], char_start, char_len[0], nextInfo, writeBuf, 0, writeBuf.length);
writeBuffOff = 0;
ip = TRANSFER_WRITEBUF;
continue;
}
}
case RESUME_CALL_FUN_SO:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_CALL_FUN_SO)) return suspendResult;
case CALL_FUN_SO:
{
int char_start;
char_len = PREPARE_CHAR_LEN(char_len);
outByteParam = PREPARE_OUT_BYTES(outByteParam);
if (tr.maxOutput <= out_stop - out_p) {
char_start = transcode_char_start(in_bytes, in_pos.p, inchar_start, in_p, char_len, outByteParam);
out_p += tr.startToOutput(state, outByteParam[0], char_start, char_len[0], out_bytes, out_p, out_stop - out_p);
ip = START;
continue;
} else {
char_start = transcode_char_start(in_bytes, in_pos.p, inchar_start, in_p, char_len, outByteParam);
writeBuffLen = tr.startToOutput(state, outByteParam[0], char_start, char_len[0], writeBuf, 0, writeBuf.length);
writeBuffOff = 0;
ip = TRANSFER_WRITEBUF;
continue;
}
}
case CALL_FUN_IO:
if (tr.maxOutput <= out_stop - out_p) {
out_p += tr.infoToOutput(state, nextInfo, out_bytes, out_p, out_stop - out_p);
ip = START;
continue;
} else {
writeBuffLen = tr.infoToOutput(state, nextInfo, writeBuf, 0, writeBuf.length);
writeBuffOff = 0;
ip = TRANSFER_WRITEBUF;
continue;
}
case RESUME_TRANSFER_WRITEBUF:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_TRANSFER_WRITEBUF)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
case TRANSFER_WRITEBUF:
while (writeBuffOff < writeBuffLen) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_TRANSFER_WRITEBUF)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
}
ip = START;
continue;
case ONE_BYTE_1:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, ONE_BYTE_1)) return suspendResult;
out_bytes[out_p++] = getBT1(nextInfo);
ip = START;
continue;
case TWO_BYTE_1:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, TWO_BYTE_1)) return suspendResult;
out_bytes[out_p++] = getBT1(nextInfo);
case TWO_BYTE_2:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, TWO_BYTE_2)) return suspendResult;
out_bytes[out_p++] = getBT2(nextInfo);
ip = START;
continue;
case FOUR_BYTE_0:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, FOUR_BYTE_0)) return suspendResult;
out_bytes[out_p++] = getBT0(nextInfo);
case FOUR_BYTE_1:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, FOUR_BYTE_1)) return suspendResult;
out_bytes[out_p++] = getBT1(nextInfo);
case FOUR_BYTE_2:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, FOUR_BYTE_2)) return suspendResult;
out_bytes[out_p++] = getBT2(nextInfo);
case FOUR_BYTE_3:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, FOUR_BYTE_3)) return suspendResult;
out_bytes[out_p++] = getBT3(nextInfo);
ip = START;
continue;
case GB_FOUR_BYTE_0:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, GB_FOUR_BYTE_0)) return suspendResult;
out_bytes[out_p++] = getGB4bt0(nextInfo);
case GB_FOUR_BYTE_1:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, GB_FOUR_BYTE_1)) return suspendResult;
out_bytes[out_p++] = getGB4bt1(nextInfo);
case GB_FOUR_BYTE_2:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, GB_FOUR_BYTE_2)) return suspendResult;
out_bytes[out_p++] = getGB4bt2(nextInfo);
case GB_FOUR_BYTE_3:
out_bytes[out_p++] = getGB4bt3(nextInfo);
ip = START;
continue;
case RESUME_STRING:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_STRING)) return suspendResult;
out_bytes[out_p++] = transcoder.byteArray[BYTE_ADDR(STR1_BYTEINDEX(nextInfo)) + 1 + outputIndex];
outputIndex++;
case STRING:
while (outputIndex < STR1_LENGTH(transcoder.byteArray, BYTE_ADDR(STR1_BYTEINDEX(nextInfo)))) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_STRING)) return suspendResult;
out_bytes[out_p++] = transcoder.byteArray[BYTE_ADDR(STR1_BYTEINDEX(nextInfo)) + 1 + outputIndex];
outputIndex++;
}
ip = START;
continue;
case RESUME_NOMAP:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_NOMAP)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
case NOMAP_TRANSFER:
while (writeBuffOff < writeBuffLen) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_NOMAP)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
}
ip = START;
continue;
case SELECT_TABLE:
while (in_p >= in_stop) {
if ((opt & EConvFlags.PARTIAL_INPUT) == 0) {
ip = REPORT_INCOMPLETE;
continue MACHINE;
}
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.SourceBufferEmpty, SELECT_TABLE);
return suspendResult;
}
nextByte = in_bytes[in_p++];
nextTable = nextInfo;
ip = FOLLOW_BYTE;
continue;
case REPORT_INVALID:
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.InvalidByteSequence, START);
return suspendResult;
case REPORT_INCOMPLETE:
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.IncompleteInput, START);
return suspendResult;
case REPORT_UNDEF:
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.UndefinedConversion, START);
return suspendResult;
case RESUME_FINISH_WRITEBUF:
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_FINISH_WRITEBUF)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
while (writeBuffOff <= writeBuffLen) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_FINISH_WRITEBUF)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
}
ip = FINISHED;
continue;
case FINISH_FUNC:
if (tr.maxOutput <= out_stop - out_p) {
out_p += tr.finish(state, out_bytes, out_p, out_stop - out_p);
} else {
writeBuffLen = tr.finish(state, writeBuf, 0, writeBuf.length);
writeBuffOff = 0;
while (writeBuffOff < writeBuffLen) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, RESUME_FINISH_WRITEBUF)) return suspendResult;
out_bytes[out_p++] = writeBuf[writeBuffOff++];
}
}
ip = FINISHED;
continue;
case CLEANUP:
if (tr.hasFinish()) {
if (SUSPEND == SUSPEND_OBUF(this, out_stop, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, CLEANUP)) return suspendResult;
ip = FINISH_FUNC;
continue;
}
case FINISHED:
SUSPEND(this, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.Finished, FINISHED);
return suspendResult;
}
}
}
private int[] PREPARE_CHAR_LEN(int[] char_len) {
if (char_len == null) {
char_len = new int[]{0};
} else {
char_len[0] = 0;
}
return char_len;
}
private byte[][] PREPARE_OUT_BYTES(byte[][] outBytes) {
if (outBytes == null) {
outBytes = new byte[1][];
} else {
outBytes[0] = null;
}
return outBytes;
}
private int transcode_char_start(byte[] in_bytes, int in_start, int inchar_start, int in_p, int[] char_len_ptr, byte[][] retBytes) {
int ptr;
byte[] bytes;
if (inchar_start - in_start < recognizedLength) {
System.arraycopy(in_bytes, inchar_start, TRANSCODING_READBUF(this), recognizedLength, in_p - inchar_start);
ptr = 0;
bytes = TRANSCODING_READBUF(this);
}
else {
ptr = inchar_start - recognizedLength;
bytes = in_bytes;
}
char_len_ptr[0] = recognizedLength + (in_p - inchar_start);
retBytes[0] = bytes;
return ptr;
}
private static int SUSPEND(Transcoding tc, byte[] in_bytes, int in_p, int inchar_start, Ptr in_pos, Ptr out_pos, int out_p, int readagain_len, EConvResult ret, int ip) {
prepareToSuspend(tc, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, ip);
tc.suspendResult = ret;
return SUSPEND;
}
private static void prepareToSuspend(Transcoding tc, byte[] in_bytes, int in_p, int inchar_start, Ptr in_pos, Ptr out_pos, int out_p, int readagain_len, int ip) {
tc.resumePosition = ip;
int recognizedLength = tc.recognizedLength;
if (in_p - inchar_start > 0) System.arraycopy(in_bytes, inchar_start, tc.readBuf, recognizedLength, in_p - inchar_start);
in_pos.p = in_p;
out_pos.p = out_p;
recognizedLength += in_p - inchar_start;
if (readagain_len != 0) {
recognizedLength -= readagain_len;
tc.readAgainLength = readagain_len;
}
tc.recognizedLength = recognizedLength;
}
private static int SUSPEND_OBUF(Transcoding tc, int out_stop, byte[] in_bytes, int in_p, int inchar_start, Ptr in_pos, Ptr out_pos, int out_p, int readagain_len, int ip) {
while (out_stop - out_p < 1) {
return SUSPEND(tc, in_bytes, in_p, inchar_start, in_pos, out_pos, out_p, readagain_len, EConvResult.DestinationBufferFull, ip);
}
return ip;
}
private static int SUSPEND_AFTER_OUTPUT(Transcoding tc, int opt, byte[] in_bytes, int in_p_offset, int inchar_start_offset, Ptr in_pos, Ptr out_pos, int out_p_offset, int readagain_len, int ip) {
if (checkAfterOutput(opt, out_pos, out_p_offset)) {
return SUSPEND(tc, in_bytes, in_p_offset, inchar_start_offset, in_pos, out_pos, out_p_offset, readagain_len, EConvResult.AfterOutput, ip);
}
return ip;
}
private static boolean checkAfterOutput(int opt, Ptr out_pos, int out_p_offset) {
return (opt & EConvFlags.AFTER_OUTPUT) != 0 && out_pos.p != out_p_offset;
}
private static final int SUSPEND = 0;
private static final int START = 1;
private static final int RESUME_AFTER_OUTPUT = 2;
private static final int NEXTBYTE = 3;
private static final int FOLLOW_BYTE = 4;
private static final int FOLLOW_INFO = 5;
private static final int NOMAP_TRANSFER = 35;
private static final int READ_MORE = 6;
private static final int CALL_FUN_SIO = 8;
private static final int RESUME_CALL_FUN_SIO = 44;
private static final int CALL_FUN_SO = 9;
private static final int RESUME_CALL_FUN_SO = 43;
private static final int CALL_FUN_IO = 10;
private static final int TRANSFER_WRITEBUF = 11;
private static final int RESUME_TRANSFER_WRITEBUF = 12;
private static final int ONE_BYTE_1 = 13;
private static final int TWO_BYTE_1 = 14;
private static final int TWO_BYTE_2 = 15;
private static final int FOUR_BYTE_1 = 16;
private static final int FOUR_BYTE_2 = 17;
private static final int FOUR_BYTE_3 = 18;
private static final int FOUR_BYTE_0 = 19;
private static final int GB_FOUR_BYTE_0 = 20;
private static final int GB_FOUR_BYTE_1 = 21;
private static final int GB_FOUR_BYTE_2 = 22;
private static final int GB_FOUR_BYTE_3 = 23;
private static final int STRING = 24;
private static final int RESUME_STRING = 25;
private static final int RESUME_NOMAP = 26;
private static final int SELECT_TABLE = 27;
private static final int REPORT_INVALID = 28;
private static final int REPORT_INCOMPLETE = 29;
private static final int REPORT_UNDEF = 30;
private static final int FINISH_FUNC = 31;
private static final int RESUME_FINISH_WRITEBUF = 32;
private static final int FINISHED = 33;
private static final int CLEANUP = 34;
private static byte[] TRANSCODING_READBUF(Transcoding tc) {
return tc.readBuf;
}
private static final int WORDINDEX_SHIFT_BITS = 2;
public static int WORDINDEX2INFO(int widx) {
return widx << WORDINDEX_SHIFT_BITS;
}
private static int INFO2WORDINDEX(int info) {
return info >>> WORDINDEX_SHIFT_BITS;
}
private static int BYTE_ADDR(int index) {
return index;
}
private static int WORD_ADDR(int index) {
return INFO2WORDINDEX(index);
}
private static int BL_BASE(Transcoding tc) {
return BYTE_ADDR(BYTE_LOOKUP_BASE(tc, WORD_ADDR(tc.nextTable)));
}
private static int BL_INFO(Transcoding tc) {
return WORD_ADDR(BYTE_LOOKUP_INFO(tc, WORD_ADDR(tc.nextTable)));
}
private static int BYTE_LOOKUP_BASE(Transcoding tc, int bl) {
return tc.transcoder.intArray[bl];
}
private static int BYTE_LOOKUP_INFO(Transcoding tc, int bl) {
return tc.transcoder.intArray[bl + 1];
}
public static int BL_MIN_BYTE(Transcoding tc) {
return tc.transcoder.byteArray[BL_BASE(tc)] & 0xFF;
}
public static int BL_MAX_BYTE(Transcoding tc) {
return tc.transcoder.byteArray[BL_BASE(tc) + 1] & 0xFF;
}
public static int BL_OFFSET(Transcoding tc, int b) {
return tc.transcoder.byteArray[BL_BASE(tc) + 2 + b - BL_MIN_BYTE(tc)] & 0xFF;
}
public static int BL_ACTION(Transcoding tc, byte b) {
return tc.transcoder.intArray[BL_INFO(tc) + BL_OFFSET(tc, b & 0xFF)];
}
public static byte getGB4bt0(int a) {
return (byte)(a >>> 8);
}
public static byte getGB4bt1(int a) {
return (byte)(((a >>> 24) & 0xf) | 0x30);
}
public static byte getGB4bt2(int a) {
return (byte)(a >>> 160);
}
public static byte getGB4bt3(int a) {
return (byte)(((a >>> 28) & 0x0f) | 0x30);
}
public static byte getBT1(int a) {
return (byte)(a >>> 8);
}
public static byte getBT2(int a) {
return (byte)(a >>> 16);
}
public static byte getBT3(int a) {
return (byte)(a >>> 24);
}
public static byte getBT0(int a) {
return (byte)(((a >>> 5) & 0x0F) | 0x30);
}
}