SMAPI/ModLoader/Mono/Cecil/PE/ByteBuffer.cs

342 lines
6.6 KiB
C#

//
// Author:
// Jb Evain (jbevain@gmail.com)
//
// Copyright (c) 2008 - 2015 Jb Evain
// Copyright (c) 2008 - 2011 Novell, Inc.
//
// Licensed under the MIT/X11 license.
//
using System;
namespace Mono.Cecil.PE {
class ByteBuffer {
internal byte [] buffer;
internal int length;
internal int position;
public ByteBuffer ()
{
this.buffer = Empty<byte>.Array;
}
public ByteBuffer (int length)
{
this.buffer = new byte [length];
}
public ByteBuffer (byte [] buffer)
{
this.buffer = buffer ?? Empty<byte>.Array;
this.length = this.buffer.Length;
}
public void Advance (int length)
{
position += length;
}
public byte ReadByte ()
{
return buffer [position++];
}
public sbyte ReadSByte ()
{
return (sbyte) ReadByte ();
}
public byte [] ReadBytes (int length)
{
var bytes = new byte [length];
Buffer.BlockCopy (buffer, position, bytes, 0, length);
position += length;
return bytes;
}
public ushort ReadUInt16 ()
{
ushort value = (ushort) (buffer [position]
| (buffer [position + 1] << 8));
position += 2;
return value;
}
public short ReadInt16 ()
{
return (short) ReadUInt16 ();
}
public uint ReadUInt32 ()
{
uint value = (uint) (buffer [position]
| (buffer [position + 1] << 8)
| (buffer [position + 2] << 16)
| (buffer [position + 3] << 24));
position += 4;
return value;
}
public int ReadInt32 ()
{
return (int) ReadUInt32 ();
}
public ulong ReadUInt64 ()
{
uint low = ReadUInt32 ();
uint high = ReadUInt32 ();
return (((ulong) high) << 32) | low;
}
public long ReadInt64 ()
{
return (long) ReadUInt64 ();
}
public uint ReadCompressedUInt32 ()
{
byte first = ReadByte ();
if ((first & 0x80) == 0)
return first;
if ((first & 0x40) == 0)
return ((uint) (first & ~0x80) << 8)
| ReadByte ();
return ((uint) (first & ~0xc0) << 24)
| (uint) ReadByte () << 16
| (uint) ReadByte () << 8
| ReadByte ();
}
public int ReadCompressedInt32 ()
{
var b = buffer [position];
var u = (int) ReadCompressedUInt32 ();
var v = u >> 1;
if ((u & 1) == 0)
return v;
switch (b & 0xc0)
{
case 0:
case 0x40:
return v - 0x40;
case 0x80:
return v - 0x2000;
default:
return v - 0x10000000;
}
}
public float ReadSingle ()
{
if (!BitConverter.IsLittleEndian) {
var bytes = ReadBytes (4);
Array.Reverse (bytes);
return BitConverter.ToSingle (bytes, 0);
}
float value = BitConverter.ToSingle (buffer, position);
position += 4;
return value;
}
public double ReadDouble ()
{
if (!BitConverter.IsLittleEndian) {
var bytes = ReadBytes (8);
Array.Reverse (bytes);
return BitConverter.ToDouble (bytes, 0);
}
double value = BitConverter.ToDouble (buffer, position);
position += 8;
return value;
}
#if !READ_ONLY
public void WriteByte (byte value)
{
if (position == buffer.Length)
Grow (1);
buffer [position++] = value;
if (position > length)
length = position;
}
public void WriteSByte (sbyte value)
{
WriteByte ((byte) value);
}
public void WriteUInt16 (ushort value)
{
if (position + 2 > buffer.Length)
Grow (2);
buffer [position++] = (byte) value;
buffer [position++] = (byte) (value >> 8);
if (position > length)
length = position;
}
public void WriteInt16 (short value)
{
WriteUInt16 ((ushort) value);
}
public void WriteUInt32 (uint value)
{
if (position + 4 > buffer.Length)
Grow (4);
buffer [position++] = (byte) value;
buffer [position++] = (byte) (value >> 8);
buffer [position++] = (byte) (value >> 16);
buffer [position++] = (byte) (value >> 24);
if (position > length)
length = position;
}
public void WriteInt32 (int value)
{
WriteUInt32 ((uint) value);
}
public void WriteUInt64 (ulong value)
{
if (position + 8 > buffer.Length)
Grow (8);
buffer [position++] = (byte) value;
buffer [position++] = (byte) (value >> 8);
buffer [position++] = (byte) (value >> 16);
buffer [position++] = (byte) (value >> 24);
buffer [position++] = (byte) (value >> 32);
buffer [position++] = (byte) (value >> 40);
buffer [position++] = (byte) (value >> 48);
buffer [position++] = (byte) (value >> 56);
if (position > length)
length = position;
}
public void WriteInt64 (long value)
{
WriteUInt64 ((ulong) value);
}
public void WriteCompressedUInt32 (uint value)
{
if (value < 0x80)
WriteByte ((byte) value);
else if (value < 0x4000) {
WriteByte ((byte) (0x80 | (value >> 8)));
WriteByte ((byte) (value & 0xff));
} else {
WriteByte ((byte) ((value >> 24) | 0xc0));
WriteByte ((byte) ((value >> 16) & 0xff));
WriteByte ((byte) ((value >> 8) & 0xff));
WriteByte ((byte) (value & 0xff));
}
}
public void WriteCompressedInt32 (int value)
{
if (value >= 0) {
WriteCompressedUInt32 ((uint) (value << 1));
return;
}
if (value > -0x40)
value = 0x40 + value;
else if (value >= -0x2000)
value = 0x2000 + value;
else if (value >= -0x20000000)
value = 0x20000000 + value;
WriteCompressedUInt32 ((uint) ((value << 1) | 1));
}
public void WriteBytes (byte [] bytes)
{
var length = bytes.Length;
if (position + length > buffer.Length)
Grow (length);
Buffer.BlockCopy (bytes, 0, buffer, position, length);
position += length;
if (position > this.length)
this.length = position;
}
public void WriteBytes (int length)
{
if (position + length > buffer.Length)
Grow (length);
position += length;
if (position > this.length)
this.length = position;
}
public void WriteBytes (ByteBuffer buffer)
{
if (position + buffer.length > this.buffer.Length)
Grow (buffer.length);
Buffer.BlockCopy (buffer.buffer, 0, this.buffer, position, buffer.length);
position += buffer.length;
if (position > this.length)
this.length = position;
}
public void WriteSingle (float value)
{
var bytes = BitConverter.GetBytes (value);
if (!BitConverter.IsLittleEndian)
Array.Reverse (bytes);
WriteBytes (bytes);
}
public void WriteDouble (double value)
{
var bytes = BitConverter.GetBytes (value);
if (!BitConverter.IsLittleEndian)
Array.Reverse (bytes);
WriteBytes (bytes);
}
void Grow (int desired)
{
var current = this.buffer;
var current_length = current.Length;
var buffer = new byte [System.Math.Max (current_length + desired, current_length * 2)];
Buffer.BlockCopy (current, 0, buffer, 0, current_length);
this.buffer = buffer;
}
#endif
}
}