256 lines
7.0 KiB
C#
256 lines
7.0 KiB
C#
|
//-----------------------------------------------------------------------------
|
||
|
//
|
||
|
// Copyright (c) Microsoft. All rights reserved.
|
||
|
// This code is licensed under the Microsoft Public License.
|
||
|
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
|
||
|
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
|
||
|
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
|
||
|
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
using System;
|
||
|
using System.IO;
|
||
|
using System.Text;
|
||
|
|
||
|
namespace Microsoft.Cci.Pdb {
|
||
|
internal class BitAccess {
|
||
|
|
||
|
internal BitAccess(int capacity) {
|
||
|
this.buffer = new byte[capacity];
|
||
|
}
|
||
|
|
||
|
internal byte[] Buffer {
|
||
|
get { return buffer; }
|
||
|
}
|
||
|
private byte[] buffer;
|
||
|
|
||
|
internal void FillBuffer(Stream stream, int capacity) {
|
||
|
MinCapacity(capacity);
|
||
|
stream.Read(buffer, 0, capacity);
|
||
|
offset = 0;
|
||
|
}
|
||
|
|
||
|
internal void Append(Stream stream, int count) {
|
||
|
int newCapacity = offset + count;
|
||
|
if (buffer.Length < newCapacity) {
|
||
|
byte[] newBuffer = new byte[newCapacity];
|
||
|
Array.Copy(buffer, newBuffer, buffer.Length);
|
||
|
buffer = newBuffer;
|
||
|
}
|
||
|
stream.Read(buffer, offset, count);
|
||
|
offset += count;
|
||
|
}
|
||
|
|
||
|
internal int Position {
|
||
|
get { return offset; }
|
||
|
set { offset = value; }
|
||
|
}
|
||
|
private int offset;
|
||
|
|
||
|
//internal void WriteBuffer(Stream stream, int count) {
|
||
|
// stream.Write(buffer, 0, count);
|
||
|
//}
|
||
|
|
||
|
internal void MinCapacity(int capacity) {
|
||
|
if (buffer.Length < capacity) {
|
||
|
buffer = new byte[capacity];
|
||
|
}
|
||
|
offset = 0;
|
||
|
}
|
||
|
|
||
|
internal void Align(int alignment) {
|
||
|
while ((offset % alignment) != 0) {
|
||
|
offset++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//internal void WriteInt32(int value) {
|
||
|
// buffer[offset + 0] = (byte)value;
|
||
|
// buffer[offset + 1] = (byte)(value >> 8);
|
||
|
// buffer[offset + 2] = (byte)(value >> 16);
|
||
|
// buffer[offset + 3] = (byte)(value >> 24);
|
||
|
// offset += 4;
|
||
|
//}
|
||
|
|
||
|
//internal void WriteInt32(int[] values) {
|
||
|
// for (int i = 0; i < values.Length; i++) {
|
||
|
// WriteInt32(values[i]);
|
||
|
// }
|
||
|
//}
|
||
|
|
||
|
//internal void WriteBytes(byte[] bytes) {
|
||
|
// for (int i = 0; i < bytes.Length; i++) {
|
||
|
// buffer[offset++] = bytes[i];
|
||
|
// }
|
||
|
//}
|
||
|
|
||
|
internal void ReadInt16(out short value) {
|
||
|
value = (short)((buffer[offset + 0] & 0xFF) |
|
||
|
(buffer[offset + 1] << 8));
|
||
|
offset += 2;
|
||
|
}
|
||
|
|
||
|
internal void ReadInt8(out sbyte value) {
|
||
|
value = (sbyte)buffer[offset];
|
||
|
offset += 1;
|
||
|
}
|
||
|
|
||
|
internal void ReadInt32(out int value) {
|
||
|
value = (int)((buffer[offset + 0] & 0xFF) |
|
||
|
(buffer[offset + 1] << 8) |
|
||
|
(buffer[offset + 2] << 16) |
|
||
|
(buffer[offset + 3] << 24));
|
||
|
offset += 4;
|
||
|
}
|
||
|
|
||
|
internal void ReadInt64(out long value) {
|
||
|
value = (long)(((ulong)buffer[offset + 0] & 0xFF) |
|
||
|
((ulong)buffer[offset + 1] << 8) |
|
||
|
((ulong)buffer[offset + 2] << 16) |
|
||
|
((ulong)buffer[offset + 3] << 24) |
|
||
|
((ulong)buffer[offset + 4] << 32) |
|
||
|
((ulong)buffer[offset + 5] << 40) |
|
||
|
((ulong)buffer[offset + 6] << 48) |
|
||
|
((ulong)buffer[offset + 7] << 56));
|
||
|
offset += 8;
|
||
|
}
|
||
|
|
||
|
internal void ReadUInt16(out ushort value) {
|
||
|
value = (ushort)((buffer[offset + 0] & 0xFF) |
|
||
|
(buffer[offset + 1] << 8));
|
||
|
offset += 2;
|
||
|
}
|
||
|
|
||
|
internal void ReadUInt8(out byte value) {
|
||
|
value = (byte)((buffer[offset + 0] & 0xFF));
|
||
|
offset += 1;
|
||
|
}
|
||
|
|
||
|
internal void ReadUInt32(out uint value) {
|
||
|
value = (uint)((buffer[offset + 0] & 0xFF) |
|
||
|
(buffer[offset + 1] << 8) |
|
||
|
(buffer[offset + 2] << 16) |
|
||
|
(buffer[offset + 3] << 24));
|
||
|
offset += 4;
|
||
|
}
|
||
|
|
||
|
internal void ReadUInt64(out ulong value) {
|
||
|
value = (ulong)(((ulong)buffer[offset + 0] & 0xFF) |
|
||
|
((ulong)buffer[offset + 1] << 8) |
|
||
|
((ulong)buffer[offset + 2] << 16) |
|
||
|
((ulong)buffer[offset + 3] << 24) |
|
||
|
((ulong)buffer[offset + 4] << 32) |
|
||
|
((ulong)buffer[offset + 5] << 40) |
|
||
|
((ulong)buffer[offset + 6] << 48) |
|
||
|
((ulong)buffer[offset + 7] << 56));
|
||
|
offset += 8;
|
||
|
}
|
||
|
|
||
|
internal void ReadInt32(int[] values) {
|
||
|
for (int i = 0; i < values.Length; i++) {
|
||
|
ReadInt32(out values[i]);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
internal void ReadUInt32(uint[] values) {
|
||
|
for (int i = 0; i < values.Length; i++) {
|
||
|
ReadUInt32(out values[i]);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
internal void ReadBytes(byte[] bytes) {
|
||
|
for (int i = 0; i < bytes.Length; i++) {
|
||
|
bytes[i] = buffer[offset++];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
internal float ReadFloat() {
|
||
|
float result = BitConverter.ToSingle(buffer, offset);
|
||
|
offset += 4;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
internal double ReadDouble() {
|
||
|
double result = BitConverter.ToDouble(buffer, offset);
|
||
|
offset += 8;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
internal decimal ReadDecimal() {
|
||
|
int[] bits = new int[4];
|
||
|
this.ReadInt32(bits);
|
||
|
return new decimal(bits[2], bits[3], bits[1], bits[0] < 0, (byte)((bits[0] & 0x00FF0000) >> 16));
|
||
|
}
|
||
|
|
||
|
internal void ReadBString(out string value) {
|
||
|
ushort len;
|
||
|
this.ReadUInt16(out len);
|
||
|
value = Encoding.UTF8.GetString(buffer, offset, len);
|
||
|
offset += len;
|
||
|
}
|
||
|
|
||
|
internal string ReadBString(int len) {
|
||
|
var result = Encoding.UTF8.GetString(buffer, offset, len);
|
||
|
offset += len;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
internal void ReadCString(out string value) {
|
||
|
int len = 0;
|
||
|
while (offset + len < buffer.Length && buffer[offset + len] != 0) {
|
||
|
len++;
|
||
|
}
|
||
|
value = Encoding.UTF8.GetString(buffer, offset, len);
|
||
|
offset += len + 1;
|
||
|
}
|
||
|
|
||
|
internal void SkipCString(out string value) {
|
||
|
int len = 0;
|
||
|
while (offset + len < buffer.Length && buffer[offset + len] != 0) {
|
||
|
len++;
|
||
|
}
|
||
|
offset += len + 1;
|
||
|
value= null;
|
||
|
}
|
||
|
|
||
|
internal void ReadGuid(out Guid guid) {
|
||
|
uint a;
|
||
|
ushort b;
|
||
|
ushort c;
|
||
|
byte d;
|
||
|
byte e;
|
||
|
byte f;
|
||
|
byte g;
|
||
|
byte h;
|
||
|
byte i;
|
||
|
byte j;
|
||
|
byte k;
|
||
|
|
||
|
ReadUInt32(out a);
|
||
|
ReadUInt16(out b);
|
||
|
ReadUInt16(out c);
|
||
|
ReadUInt8(out d);
|
||
|
ReadUInt8(out e);
|
||
|
ReadUInt8(out f);
|
||
|
ReadUInt8(out g);
|
||
|
ReadUInt8(out h);
|
||
|
ReadUInt8(out i);
|
||
|
ReadUInt8(out j);
|
||
|
ReadUInt8(out k);
|
||
|
|
||
|
guid = new Guid(a, b, c, d, e, f, g, h, i, j, k);
|
||
|
}
|
||
|
|
||
|
internal string ReadString() {
|
||
|
int len = 0;
|
||
|
while (offset + len < buffer.Length && buffer[offset + len] != 0) {
|
||
|
len+=2;
|
||
|
}
|
||
|
string result = Encoding.Unicode.GetString(buffer, offset, len);
|
||
|
offset += len + 2;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
}
|