564 lines
15 KiB
C#
564 lines
15 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using forms_cil;
|
|
|
|
namespace UnitTestProject.RefVm
|
|
{
|
|
// Token: 0x0200000A RID: 10
|
|
internal sealed class MyBufferReader : IDisposable // \u0002\u2007
|
|
{
|
|
// Token: 0x0400000C RID: 12
|
|
private MyBuffer _src; // \u0002
|
|
|
|
// Token: 0x0400000D RID: 13
|
|
private byte[] _inputRawBuf; // \u0003
|
|
|
|
// Token: 0x0400000E RID: 14
|
|
private Decoder _decoder; // \u0005
|
|
|
|
// Token: 0x0400000F RID: 15
|
|
private byte[] _inputCharRawBuf; // \u0008
|
|
|
|
// Token: 0x04000010 RID: 16
|
|
private char[] _inputCharsDecoded; // \u0006
|
|
|
|
// Token: 0x04000011 RID: 17
|
|
private char[] _stringChunk; // \u000E
|
|
|
|
// Token: 0x04000012 RID: 18
|
|
private readonly int _maxCharsIn128Bytes; // \u000F
|
|
|
|
// Token: 0x04000013 RID: 19
|
|
private readonly bool _isUnicode; // \u0002\u2000
|
|
|
|
// Token: 0x04000014 RID: 20
|
|
private readonly bool _alwaysTrue; // \u0003\u2000
|
|
|
|
// Token: 0x06000034 RID: 52 RVA: 0x000027C8 File Offset: 0x000009C8
|
|
public MyBufferReader(MyBuffer src) : this(src, new UTF8Encoding())
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000035 RID: 53 RVA: 0x000027D8 File Offset: 0x000009D8
|
|
private MyBufferReader(MyBuffer src, Encoding encoding)
|
|
{
|
|
if (src == null)
|
|
{
|
|
throw new ArgumentNullException();
|
|
}
|
|
if (encoding == null)
|
|
{
|
|
throw new ArgumentNullException();
|
|
}
|
|
if (!src.IsValid())
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
_src = src;
|
|
_decoder = encoding.GetDecoder();
|
|
_maxCharsIn128Bytes = encoding.GetMaxCharCount(128);
|
|
var num = encoding.GetMaxByteCount(1);
|
|
if (num < 16)
|
|
num = 16;
|
|
_inputRawBuf = new byte[num];
|
|
_stringChunk = null;
|
|
_inputCharRawBuf = null;
|
|
_isUnicode = (encoding is UnicodeEncoding);
|
|
_alwaysTrue = (_src != null);
|
|
}
|
|
|
|
// Token: 0x06000036 RID: 54 RVA: 0x00002878 File Offset: 0x00000A78
|
|
public MyBuffer GetBuffer() // \u0002
|
|
{
|
|
return _src;
|
|
}
|
|
|
|
// Token: 0x06000037 RID: 55 RVA: 0x00002880 File Offset: 0x00000A80
|
|
public void Dispose() // \u0002
|
|
{
|
|
DoDispose(true);
|
|
}
|
|
|
|
// Token: 0x06000038 RID: 56 RVA: 0x0000288C File Offset: 0x00000A8C
|
|
private void DoDispose(bool disposing) // \u0002
|
|
{
|
|
if (disposing)
|
|
_src?.DoDispose();
|
|
_src = null;
|
|
_inputRawBuf = null;
|
|
_decoder = null;
|
|
_inputCharRawBuf = null;
|
|
_inputCharsDecoded = null;
|
|
_stringChunk = null;
|
|
}
|
|
|
|
// Token: 0x06000039 RID: 57 RVA: 0x000028E0 File Offset: 0x00000AE0
|
|
void IDisposable.Dispose() // \u0002\u2007\u2008\u2000\u2002\u200A\u0003
|
|
{
|
|
DoDispose(true);
|
|
}
|
|
|
|
// Token: 0x0600003A RID: 58 RVA: 0x000028EC File Offset: 0x00000AEC
|
|
public int PeekUnicodeChar() // \u0002
|
|
{
|
|
SrcPrecondition();
|
|
if (!_src.IsValid2())
|
|
{
|
|
return -1;
|
|
}
|
|
var pos = _src.GetPos();
|
|
var ret = SafeReadUnicodeChar();
|
|
_src.SetPos(pos);
|
|
return ret;
|
|
}
|
|
|
|
// Token: 0x06000051 RID: 81 RVA: 0x00002FE8 File Offset: 0x000011E8
|
|
private void SrcPrecondition() // \u0005
|
|
{
|
|
if (_src == null)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600003B RID: 59 RVA: 0x0000292C File Offset: 0x00000B2C
|
|
public int SafeReadUnicodeChar() // \u0003
|
|
{
|
|
SrcPrecondition();
|
|
return ReadUnicodeChar();
|
|
}
|
|
|
|
// Token: 0x0600004E RID: 78 RVA: 0x00002E38 File Offset: 0x00001038
|
|
private int ReadUnicodeChar() // \u0005
|
|
{
|
|
var charCnt = 0;
|
|
var savedPos = 0L;
|
|
if (_src.IsValid2())
|
|
{
|
|
savedPos = _src.GetPos();
|
|
}
|
|
if (_inputCharRawBuf == null)
|
|
{
|
|
_inputCharRawBuf = new byte[128];
|
|
}
|
|
if (_inputCharsDecoded == null)
|
|
{
|
|
_inputCharsDecoded = new char[1];
|
|
}
|
|
while (charCnt == 0)
|
|
{
|
|
var bytesToRead = _isUnicode ? 2 : 1;
|
|
var b = _src.ReadByte();
|
|
_inputCharRawBuf[0] = (byte)b;
|
|
if (b == -1)
|
|
{
|
|
bytesToRead = 0;
|
|
}
|
|
if (bytesToRead == 2)
|
|
{
|
|
b = _src.ReadByte();
|
|
_inputCharRawBuf[1] = (byte)b;
|
|
if (b == -1)
|
|
{
|
|
bytesToRead = 1;
|
|
}
|
|
}
|
|
if (bytesToRead == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
try
|
|
{
|
|
charCnt = _decoder.GetChars(_inputCharRawBuf, 0, bytesToRead, _inputCharsDecoded, 0);
|
|
}
|
|
catch
|
|
{
|
|
if (_src.IsValid2())
|
|
{
|
|
_src.Seek(savedPos - _src.GetPos(), SeekOrigin.Current);
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
if (charCnt == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
return _inputCharsDecoded[0];
|
|
}
|
|
|
|
// Token: 0x06000053 RID: 83 RVA: 0x0000305C File Offset: 0x0000125C
|
|
private void ReadToRawBuf(int cnt) // \u0002
|
|
{
|
|
SrcPrecondition();
|
|
var offset = 0;
|
|
int bytesRead;
|
|
if (cnt != 1)
|
|
{
|
|
while (true)
|
|
{
|
|
bytesRead = _src.Read(_inputRawBuf, offset, cnt - offset);
|
|
if (bytesRead == 0)
|
|
break;
|
|
offset += bytesRead;
|
|
if (offset >= cnt)
|
|
return;
|
|
}
|
|
throw new Exception();
|
|
}
|
|
bytesRead = _src.ReadByte();
|
|
if (bytesRead == -1)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
_inputRawBuf[0] = (byte)bytesRead;
|
|
}
|
|
|
|
// Token: 0x0600003C RID: 60 RVA: 0x0000293C File Offset: 0x00000B3C
|
|
public bool ReadByteInternal() // \u0002
|
|
{
|
|
ReadToRawBuf(1);
|
|
return _inputRawBuf[0] > 0;
|
|
}
|
|
|
|
// Token: 0x0600003D RID: 61 RVA: 0x00002950 File Offset: 0x00000B50
|
|
public byte ReadByte() // \u0002
|
|
{
|
|
SrcPrecondition();
|
|
var b = _src.ReadByte();
|
|
if (b == -1)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
return (byte)b;
|
|
}
|
|
|
|
// Token: 0x0600003E RID: 62 RVA: 0x00002970 File Offset: 0x00000B70
|
|
public sbyte ReadSbyte() // \u0002
|
|
{
|
|
ReadToRawBuf(1);
|
|
return (sbyte)_inputRawBuf[0];
|
|
}
|
|
|
|
// Token: 0x0600003F RID: 63 RVA: 0x00002984 File Offset: 0x00000B84
|
|
public char ReadChar() // \u0002
|
|
{
|
|
var c = SafeReadUnicodeChar();
|
|
if (c == -1)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
return (char)c;
|
|
}
|
|
|
|
// Token: 0x06000040 RID: 64 RVA: 0x00002998 File Offset: 0x00000B98
|
|
public short ReadShort() // \u0002
|
|
{
|
|
ReadToRawBuf(2);
|
|
return (short)(_inputRawBuf[0] | _inputRawBuf[1] << 8);
|
|
}
|
|
|
|
// Token: 0x06000041 RID: 65 RVA: 0x000029B8 File Offset: 0x00000BB8
|
|
public ushort ReadUshort() // \u0002
|
|
{
|
|
ReadToRawBuf(2);
|
|
return (ushort)(_inputRawBuf[0] | _inputRawBuf[1] << 8);
|
|
}
|
|
|
|
// Token: 0x06000042 RID: 66 RVA: 0x000029D8 File Offset: 0x00000BD8
|
|
public uint ReadUint() // \u0002
|
|
{
|
|
ReadToRawBuf(4);
|
|
return (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
|
}
|
|
|
|
// Token: 0x06000043 RID: 67 RVA: 0x00002A0C File Offset: 0x00000C0C
|
|
public long ReadLong() // \u0002
|
|
{
|
|
ReadToRawBuf(8);
|
|
var num = (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
|
return (long)((ulong)(_inputRawBuf[4] | _inputRawBuf[5] << 8 | _inputRawBuf[6] << 16 | _inputRawBuf[7] << 24) << 32 | num);
|
|
}
|
|
|
|
// Token: 0x06000044 RID: 68 RVA: 0x00002A80 File Offset: 0x00000C80
|
|
public ulong ReadUlong() // \u0002
|
|
{
|
|
ReadToRawBuf(8);
|
|
var num = (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
|
return (ulong)(_inputRawBuf[4] | _inputRawBuf[5] << 8 | _inputRawBuf[6] << 16 | _inputRawBuf[7] << 24) << 32 | num;
|
|
}
|
|
|
|
// Token: 0x06000045 RID: 69 RVA: 0x00002AF4 File Offset: 0x00000CF4
|
|
private BinaryReader ReaderFor(int cnt) // \u0002
|
|
{
|
|
ReadToRawBuf(cnt);
|
|
return new BinaryReader(new MemoryStream(_inputRawBuf, 0, cnt, false));
|
|
}
|
|
|
|
// Token: 0x06000046 RID: 70 RVA: 0x00002B10 File Offset: 0x00000D10
|
|
public float ReadFloat() // \u0002
|
|
{
|
|
var r = ReaderFor(4);
|
|
var result = r.ReadSingle();
|
|
r.Close();
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000047 RID: 71 RVA: 0x00002B34 File Offset: 0x00000D34
|
|
public double ReadDouble() // \u0002
|
|
{
|
|
var r = ReaderFor(8);
|
|
var result = r.ReadDouble();
|
|
r.Close();
|
|
return result;
|
|
}
|
|
|
|
// Token: 0x06000048 RID: 72 RVA: 0x00002B58 File Offset: 0x00000D58
|
|
private static decimal CreateDecimal(int lo, int mid, int hi, int scaleNeg) // \u0002
|
|
{
|
|
var isNegative = (scaleNeg & -2147483648) != 0;
|
|
var scale = (byte)(scaleNeg >> 16);
|
|
return new decimal(lo, mid, hi, isNegative, scale);
|
|
}
|
|
|
|
// Token: 0x06000049 RID: 73 RVA: 0x00002B80 File Offset: 0x00000D80
|
|
internal static decimal CreateDecimal(byte[] b) // b
|
|
{
|
|
var lo = b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24;
|
|
var mid = b[4] | b[5] << 8 | b[6] << 16 | b[7] << 24;
|
|
var hi = b[8] | b[9] << 8 | b[10] << 16 | b[11] << 24;
|
|
var scaleNeg = b[12] | b[13] << 8 | b[14] << 16 | b[15] << 24;
|
|
return CreateDecimal(lo, mid, hi, scaleNeg);
|
|
}
|
|
|
|
// Token: 0x0600004A RID: 74 RVA: 0x00002BFC File Offset: 0x00000DFC
|
|
public decimal ReadDecimal() // \u0002
|
|
{
|
|
ReadToRawBuf(16);
|
|
return CreateDecimal(_inputRawBuf);
|
|
}
|
|
|
|
// Token: 0x0600004B RID: 75 RVA: 0x00002C14 File Offset: 0x00000E14
|
|
public string ReadString() // \u0002
|
|
{
|
|
var totalRead = 0;
|
|
SrcPrecondition();
|
|
var strLen = Read28Bit();
|
|
if (strLen < 0)
|
|
{
|
|
throw new IOException();
|
|
}
|
|
if (strLen == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
if (_inputCharRawBuf == null)
|
|
{
|
|
_inputCharRawBuf = new byte[128];
|
|
}
|
|
if (_stringChunk == null)
|
|
{
|
|
_stringChunk = new char[_maxCharsIn128Bytes];
|
|
}
|
|
StringBuilder stringBuilder = null;
|
|
while (true)
|
|
{
|
|
var needChunkCnt = (strLen - totalRead > 128) ? 128 : (strLen - totalRead);
|
|
var realChunkRead = _src.Read(_inputCharRawBuf, 0, needChunkCnt);
|
|
if (realChunkRead == 0)
|
|
{
|
|
break;
|
|
}
|
|
var chars = _decoder.GetChars(_inputCharRawBuf, 0, realChunkRead, _stringChunk, 0);
|
|
if (totalRead == 0 && realChunkRead == strLen)
|
|
{
|
|
return new string(_stringChunk, 0, chars);
|
|
}
|
|
if (stringBuilder == null)
|
|
{
|
|
stringBuilder = new StringBuilder(strLen);
|
|
}
|
|
stringBuilder.Append(_stringChunk, 0, chars);
|
|
totalRead += realChunkRead;
|
|
if (totalRead >= strLen)
|
|
{
|
|
return stringBuilder.ToString();
|
|
}
|
|
}
|
|
throw new Exception();
|
|
}
|
|
|
|
// Token: 0x0600004C RID: 76 RVA: 0x00002D08 File Offset: 0x00000F08
|
|
public int Read(char[] dest, int offset, int cnt) // \u0002
|
|
{
|
|
if (dest == null)
|
|
{
|
|
throw new ArgumentNullException(StringDecryptor.GetString(-1550347170), /* \u0002 */
|
|
StringDecryptor.GetString(-1550347157) /* ArgumentNull_Buffer */);
|
|
}
|
|
if (offset < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
if (cnt < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
if (dest.Length - offset < cnt)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
SrcPrecondition();
|
|
return DoRead(dest, offset, cnt);
|
|
}
|
|
|
|
// Token: 0x0600004D RID: 77 RVA: 0x00002D64 File Offset: 0x00000F64
|
|
private int DoRead(char[] dest, int offset, int cnt) // \u0003
|
|
{
|
|
var remainCharsToRead = cnt;
|
|
if (_inputCharRawBuf == null)
|
|
{
|
|
_inputCharRawBuf = new byte[128];
|
|
}
|
|
while (remainCharsToRead > 0)
|
|
{
|
|
var chunkSize = remainCharsToRead;
|
|
if (_isUnicode)
|
|
{
|
|
chunkSize <<= 1;
|
|
}
|
|
if (chunkSize > 128)
|
|
{
|
|
chunkSize = 128;
|
|
}
|
|
int chars;
|
|
if (_alwaysTrue)
|
|
{
|
|
var byteIndex = _src.GetCursor();
|
|
chunkSize = _src.SkipBytes(chunkSize);
|
|
if (chunkSize == 0)
|
|
{
|
|
return cnt - remainCharsToRead;
|
|
}
|
|
chars = _decoder.GetChars(_src.Data(), byteIndex, chunkSize, dest, offset);
|
|
}
|
|
else
|
|
{
|
|
chunkSize = _src.Read(_inputCharRawBuf, 0, chunkSize);
|
|
if (chunkSize == 0)
|
|
{
|
|
return cnt - remainCharsToRead;
|
|
}
|
|
chars = _decoder.GetChars(_inputCharRawBuf, 0, chunkSize, dest, offset);
|
|
}
|
|
remainCharsToRead -= chars;
|
|
offset += chars;
|
|
}
|
|
return cnt;
|
|
}
|
|
|
|
|
|
// Token: 0x0600004F RID: 79 RVA: 0x00002F54 File Offset: 0x00001154
|
|
public char[] ReadChars(int cnt) // \u0002
|
|
{
|
|
SrcPrecondition();
|
|
if (cnt < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
var ret = new char[cnt];
|
|
var realLength = DoRead(ret, 0, cnt);
|
|
if (realLength != cnt)
|
|
{
|
|
var shrinked = new char[realLength];
|
|
Buffer.BlockCopy(ret, 0, shrinked, 0, 2 * realLength);
|
|
ret = shrinked;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Token: 0x06000050 RID: 80 RVA: 0x00002F9C File Offset: 0x0000119C
|
|
public int Read(byte[] dest, int offset, int cnt) // dest
|
|
{
|
|
if (dest == null)
|
|
{
|
|
throw new ArgumentNullException();
|
|
}
|
|
if (offset < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
if (cnt < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
if (dest.Length - offset < cnt)
|
|
{
|
|
throw new ArgumentException();
|
|
}
|
|
SrcPrecondition();
|
|
return _src.Read(dest, offset, cnt);
|
|
}
|
|
|
|
// Token: 0x06000052 RID: 82 RVA: 0x00002FF8 File Offset: 0x000011F8
|
|
public byte[] ReadBytes(int cnt) // \u0002
|
|
{
|
|
if (cnt < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
SrcPrecondition();
|
|
var ret = new byte[cnt];
|
|
var offset = 0;
|
|
do
|
|
{
|
|
var chunkSize = _src.Read(ret, offset, cnt);
|
|
if (chunkSize == 0)
|
|
{
|
|
break;
|
|
}
|
|
offset += chunkSize;
|
|
cnt -= chunkSize;
|
|
}
|
|
while (cnt > 0);
|
|
if (offset != ret.Length)
|
|
{
|
|
var shrinked = new byte[offset];
|
|
Buffer.BlockCopy(ret, 0, shrinked, 0, offset);
|
|
ret = shrinked;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Token: 0x06000054 RID: 84 RVA: 0x000030C0 File Offset: 0x000012C0
|
|
internal int Read28Bit() // \u0008
|
|
{
|
|
var ret = 0;
|
|
var bitCnt = 0;
|
|
while (bitCnt != 35)
|
|
{
|
|
var b = ReadByte();
|
|
ret |= (b & 127) << bitCnt;
|
|
bitCnt += 7;
|
|
if ((b & 128) == 0)
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
throw new FormatException();
|
|
}
|
|
|
|
// Token: 0x06000055 RID: 85 RVA: 0x00003100 File Offset: 0x00001300
|
|
public int ReadInt32() // \u0006
|
|
{
|
|
if (_alwaysTrue)
|
|
{
|
|
return _src.ReadInt32();
|
|
}
|
|
ReadToRawBuf(4);
|
|
return _inputRawBuf[3] << 8 | _inputRawBuf[1] << 24 | _inputRawBuf[0] << 16 | _inputRawBuf[2];
|
|
}
|
|
}
|
|
}
|