/// <summary>
/// erzeugt einen StringBuilder mit den Hex-Werten des <see cref="BinaryReaderWriter"/>
/// </summary>
/// <param name="br"></param>
/// <param name="start">Index des 1. Bytes</param>
/// <param name="length">Länge des Bereiches</param>
/// <param name="bytesperline">wenn größer 0 wird für die entsprechende Anzahl Bytes jeweils eine neue Zeile verwendet</param>
/// <returns></returns>
static public StringBuilder DumpMemory(BinaryReaderWriter br, int start = -1, int length = -1, int bytesperline = -1)
{
if (start >= 0)
{
br.Seek(start);
}
byte[] buff = br.ReadBytes(length > 0 ? length : (int)(br.Length - br.Position));
return(DumpMemory(buff, 0, buff.Length, bytesperline));
}
/// <summary>
/// liefert 3 Byte als signed Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public int Read3Int(BinaryReaderWriter br)
{
int v = ReadByte(br) + (ReadByte(br) << 8) + (ReadByte(br) << 16);
if (v >= 0x800000)
{
v -= 0x1000000;
}
return(v);
}
/// <summary>
/// Basisfkt. zum Lesen eines Bytes (ev. auch XORt; IOException am Streamende)
/// </summary>
/// <returns></returns>
static public byte ReadByte(BinaryReaderWriter br)
{
int b = br.BaseStream.ReadByte() ^ br.XOR;
if (b == -1)
{
throw new IOException("End of file");
}
return((byte)b);
}
/// <summary>
/// liefert 4 Byte als signed Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public int Read4Int(BinaryReaderWriter br)
{
long v = ReadByte(br) + (ReadByte(br) << 8) + (ReadByte(br) << 16) + (ReadByte(br) << 24);
if (v >= 0x80000000)
{
v -= 0x100000000;
}
return((int)v);
}
/// <summary>
/// liefert 1 Byte als signed Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public int Read1Int(BinaryReaderWriter br)
{
int v = br.ReadByte();
if (v >= 0x80) // Bit 7 = 1 -> negativ
{
v -= 0x100;
}
return(v);
}
/// <summary>
/// ab der der Position des Start-Bits im <see cref="BinaryReaderWriter"/> wird die benötigte Anzahl Bits (als komplette Bytes) eingelesen
/// und als Text aufbereitet
/// </summary>
/// <param name="br"></param>
/// <param name="start">Anzahl der zu ignorierenden Bits ab der akt. Byteposition</param>
/// <param name="length">wenn größer 0 die Anzahl der Bits</param>
/// <param name="bitsperline">wenn größer 0 die Anzahl der Bits je Textzeile</param>
/// <param name="low2high">je Byte beginnend mit Bit 0 oder 7</param>
/// <returns></returns>
static public StringBuilder Dumpstream(BinaryReaderWriter br, int start = -1, int length = -1, int bitsperline = 8, bool low2high = false)
{
if (start >= 0)
{
br.Seek(start);
}
byte[] buff = br.ReadBytes(length > 0 ?
1 + length / 8 :
(int)(br.Length - br.Position));
return(Dumpstream(br, 0, length, bitsperline, low2high));
}
/// <summary>
/// Basisfkt zum Füllen des Byte-Puffer
/// </summary>
/// <param name="buff"></param>
/// <returns></returns>
static public byte[] ReadBytes(BinaryReaderWriter br, byte[] buff)
{
br.BaseStream.Read(buff, 0, buff.Length);
if (br.XOR != 0)
{
for (int i = 0; i < buff.Length; i++)
{
buff[i] ^= br.XOR;
}
}
return(buff);
}
/// <summary>
/// liest die Blockdaten
/// </summary>
/// <param name="br"></param>
public void Read(BinaryReaderWriter br)
{
Offset = br.Read4UInt();
Length = br.Read2AsUShort();
}
public ShortDataBlock(BinaryReaderWriter br)
: this()
{
Read(br);
}
/// <summary>
/// erzeugt einen StringBuilder mit den Hex-Werten des <see cref="BinaryReaderWriter"/>
/// </summary>
/// <param name="br"></param>
/// <param name="block">Index des 1. Bytes und Länge des Bereichs</param>
/// <param name="bytesperline">wenn größer 0 wird für die entsprechende Anzahl Bytes jeweils eine neue Zeile verwendet</param>
/// <returns></returns>
static public StringBuilder DumpMemory(BinaryReaderWriter br, DataBlock block, int bytesperline = -1)
{
return(DumpMemory(br, (int)block.Offset, (int)block.Length, bytesperline));
}
//public long ReadInt64() {
// basestream.Read(m_buffer, 0, 8);
// if (XOR != 0)
// for (int i = 0; i < 8; i++)
// m_buffer[i] ^= XOR;
// uint lo = (uint)(m_buffer[0] | m_buffer[1] << 8 |
// m_buffer[2] << 16 | m_buffer[3] << 24);
// uint hi = (uint)(m_buffer[4] | m_buffer[5] << 8 |
// m_buffer[6] << 16 | m_buffer[7] << 24);
// return (long)((ulong)hi) << 32 | lo;
//}
//public ulong ReadUInt64() {
// basestream.Read(m_buffer, 0, 8);
// if (XOR != 0)
// for (int i = 0; i < 8; i++)
// m_buffer[i] ^= XOR;
// uint lo = (uint)(m_buffer[0] | m_buffer[1] << 8 |
// m_buffer[2] << 16 | m_buffer[3] << 24);
// uint hi = (uint)(m_buffer[4] | m_buffer[5] << 8 |
// m_buffer[6] << 16 | m_buffer[7] << 24);
// return ((ulong)hi) << 32 | lo;
//}
#endregion
#region spez. static-Lesefkt. für den bequemeren Zugriff auf Daten (greifen auf die Kernfkt. zurück)
/// <summary>
/// liefert 1 Byte als unsigned Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public int Read1UInt(BinaryReaderWriter br)
{
return(ReadByte(br));
}
/// <summary>
/// liest die Blockdaten
/// </summary>
/// <param name="br"></param>
public new void Read(BinaryReaderWriter br)
{
base.Read(br);
Recordsize = br.Read2AsUShort();
}
/// <summary>
/// liefert 4 Byte als unsigned Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public uint Read4UInt(BinaryReaderWriter br)
{
return((uint)(ReadByte(br) + ((long)ReadByte(br) << 8) + ((long)ReadByte(br) << 16) + ((long)ReadByte(br) << 24)));
}
/// <summary>
/// liefert 3 Byte als unsigned Wert
/// </summary>
/// <param name="br"></param>
/// <returns></returns>
static public int Read3UInt(BinaryReaderWriter br)
{
return(ReadByte(br) + (ReadByte(br) << 8) + (ReadByte(br) << 16));
}
/// <summary>
/// schreibt die Blockdaten
/// </summary>
/// <param name="bw"></param>
public void Write(BinaryReaderWriter bw)
{
bw.Write(Offset);
bw.Write(Length);
}
public abstract void Read(BinaryReaderWriter br, object data);
public DataBlockWithRecordsize(BinaryReaderWriter br)
: this()
{
Read(br);
}
public abstract void Write(BinaryReaderWriter bw, object data);
/// <summary>
/// schreibt die Blockdaten
/// </summary>
/// <param name="bw"></param>
public new void Write(BinaryReaderWriter bw)
{
base.Write(bw);
bw.Write(Recordsize);
}
/// <summary>
/// kopiert die restlichen Bytes des Streams
/// </summary>
/// <param name="brw"></param>
public void CopyTo(BinaryReaderWriter brw)
{
CopyTo(brw.BaseStream);
}
