ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[NES] fully consolidated text/binary serialization, and don't save screen buffer to binary savestates

This commit is contained in:
zeromus 2011-04-17 22:51:53 +00:00
parent 40cd085509
commit db28312787
15 changed files with 342 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
BizHawk.Emulation/CPUs/MOS 6502/MOS6502.cs
View File

@ -104,69 +104,24 @@ namespace BizHawk.Emulation.CPUs.M6502
public bool IRQ;
public bool NMI;
public void SaveStateText(TextWriter writer)
public void SyncState(Serializer ser)
{
writer.WriteLine("[MOS6502]");
writer.WriteLine("A {0:X2}", A);
writer.WriteLine("X {0:X2}", X);
writer.WriteLine("Y {0:X2}", Y);
writer.WriteLine("P {0:X2}", P);
writer.WriteLine("PC {0:X4}", PC);
writer.WriteLine("S {0:X2}", S);
writer.WriteLine("NMI {0}", NMI);
writer.WriteLine("IRQ {0}", IRQ);
writer.WriteLine("TotalExecutedCycles {0}", TotalExecutedCycles);
writer.WriteLine("PendingCycles {0}", PendingCycles);
writer.WriteLine("[/MOS6502]\n");
ser.BeginSection("MOS6502");
ser.Sync("A", ref A);
ser.Sync("X", ref X);
ser.Sync("Y", ref Y);
ser.Sync("P", ref P);
ser.Sync("PC", ref PC);
ser.Sync("S", ref S);
ser.Sync("NMI", ref NMI);
ser.Sync("IRQ", ref IRQ);
ser.Sync("TotalExecutedCycles", ref TotalExecutedCycles);
ser.Sync("PendingCycles", ref PendingCycles);
ser.EndSection();
}
public void LoadStateText(TextReader reader)
{
while (true)
{
string[] args = reader.ReadLine().Split(' ');
if (args[0].Trim() == "") continue;
if (args[0] == "[/MOS6502]") break;
if (args[0] == "A")
A = byte.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "X")
X = byte.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "Y")
Y = byte.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "P")
P = byte.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "PC")
PC = ushort.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "S")
S = byte.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "NMI")
NMI = bool.Parse(args[1]);
else if (args[0] == "IRQ")
IRQ = bool.Parse(args[1]);
else if (args[0] == "TotalExecutedCycles")
TotalExecutedCycles = int.Parse(args[1]);
else if (args[0] == "PendingCycles")
PendingCycles = int.Parse(args[1]);
else
Console.WriteLine("Skipping unrecognized identifier " + args[0]);
}
}
void SyncStateBinary(BinarySerializer ser)
{
ser.Sync(ref A);
ser.Sync(ref X);
ser.Sync(ref Y);
ser.Sync(ref P);
ser.Sync(ref PC);
ser.Sync(ref S);
ser.Sync(ref NMI);
ser.Sync(ref IRQ);
ser.Sync(ref TotalExecutedCycles);
ser.Sync(ref PendingCycles);
}
public void SaveStateBinary(BinaryWriter writer) { SyncStateBinary(BinarySerializer.CreateWriter(writer)); }
public void LoadStateBinary(BinaryReader reader) { SyncStateBinary(BinarySerializer.CreateReader(reader)); }
public void SaveStateBinary(BinaryWriter writer) { SyncState(Serializer.CreateBinaryWriter(writer)); }
public void LoadStateBinary(BinaryReader reader) { SyncState(Serializer.CreateBinaryReader(reader)); }
// ==== End State ====

10
BizHawk.Emulation/Consoles/Nintendo/NES/BoardSystem.cs
View File

@ -26,7 +26,7 @@ namespace BizHawk.Emulation.Consoles.Nintendo
byte[] VRAM { get; set; }
byte[] ROM { get; set; }
byte[] VROM { get; set; }
void SyncStateBinary(BinarySerializer ser);
void SyncState(Serializer ser);
};
@ -42,11 +42,11 @@ namespace BizHawk.Emulation.Consoles.Nintendo
public CartInfo Cart { get { return NES.cart; } }
public NES NES { get; set; }
public virtual void SyncStateBinary(BinarySerializer ser)
public virtual void SyncState(Serializer ser)
{
ser.Sync(ref vram,true);
ser.Sync(ref wram,true);
for (int i = 0; i < 4; i++) ser.Sync(ref mirroring[i]);
ser.Sync("vram", ref vram, true);
ser.Sync("wram", ref wram, true);
for (int i = 0; i < 4; i++) ser.Sync("mirroring" + i, ref mirroring[i]);
}

6
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/AxROM.cs
View File

@ -88,10 +88,10 @@ namespace BizHawk.Emulation.Consoles.Nintendo
else base.WritePPU(addr,value);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref prg);
base.SyncState(ser);
ser.Sync("prg",ref prg);
}
}

6
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CPROM.cs
View File

@ -54,10 +54,10 @@ namespace BizHawk.Emulation.Consoles.Nintendo
else base.WritePPU(addr,value);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref chr);
base.SyncState(ser);
ser.Sync("chr",ref chr);
}

6
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/CxROM.cs
View File

@ -59,10 +59,10 @@ namespace BizHawk.Emulation.Consoles.Nintendo
else return base.ReadPPU(addr);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref chr);
base.SyncState(ser);
ser.Sync("chr",ref chr);
}
}

10
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/GxROM.cs
View File

@ -31,7 +31,7 @@ namespace BizHawk.Emulation.Consoles.Nintendo
case "BANDAI-GNROM":
case "HVC-GNROM":
case "NES-MHROM": //Super Mario Bros. / Duck Hunt
AssertPrg(Cart.board_type == "NES-MHROM" ? 64 : 128); AssertChr(8, 16, 32); AssertVram(0); AssertWram(0);
//AssertPrg(Cart.board_type == "NES-MHROM" ? 64 : 128); AssertChr(8, 16, 32); AssertVram(0); AssertWram(0);
break;
default:
@ -67,11 +67,11 @@ namespace BizHawk.Emulation.Consoles.Nintendo
prg = (((value>>4) & 3) & prg_mask);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref chr);
ser.Sync(ref prg);
base.SyncState(ser);
ser.Sync("chr", ref chr);
ser.Sync("prg", ref prg);
}
}
}

8
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/IC_74x377.cs
View File

@ -62,11 +62,11 @@ namespace BizHawk.Emulation.Consoles.Nintendo
chr = (value >> 4) & chr_mask;
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref chr);
ser.Sync(ref prg);
base.SyncState(ser);
ser.Sync("chr", ref chr);
ser.Sync("prg", ref prg);
}
}

4
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Jaleco-JF_11_14.cs
View File

@ -44,9 +44,9 @@ Other chips used: Sunsoft-1
return base.ReadPPU(addr);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
base.SyncState(ser);
}
}
}

8
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/Sunsoft1.cs
View File

@ -64,11 +64,11 @@ Other chips used: Sunsoft-1
right_piece = (value >> 4) & 7 & chr_mask;
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref left_piece);
ser.Sync(ref right_piece);
base.SyncState(ser);
ser.Sync("left_piece", ref left_piece);
ser.Sync("right_piece", ref right_piece);
}
}
}

29
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/SxROM.cs
View File

@ -33,19 +33,18 @@ namespace BizHawk.Emulation.Consoles.Nintendo
//well, lets leave it.
}
public void SyncStateBinary(BinarySerializer ser)
public void SyncState(Serializer ser)
{
ser.Sync(ref shift_count);
ser.Sync(ref shift_val);
ser.Sync(ref chr_mode);
ser.Sync(ref prg_mode);
ser.Sync(ref prg_slot);
ser.Sync(ref chr_0);
ser.Sync(ref chr_1);
ser.Sync(ref wram_disable);
ser.Sync(ref prg);
ser.SyncEnum(ref mirror);
ser.Sync("shift_count", ref shift_count);
ser.Sync("shift_val", ref shift_val);
ser.Sync("chr_mode", ref chr_mode);
ser.Sync("prg_mode", ref prg_mode);
ser.Sync("prg_slot", ref prg_slot);
ser.Sync("chr_0", ref chr_0);
ser.Sync("chr_1", ref chr_1);
ser.Sync("wram_disable", ref wram_disable);
ser.Sync("prg", ref prg);
ser.SyncEnum("mirror", ref mirror);
}
public enum Rev
@ -231,10 +230,10 @@ namespace BizHawk.Emulation.Consoles.Nintendo
}
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
mmc1.SyncStateBinary(ser);
base.SyncState(ser);
mmc1.SyncState(ser);
}

6
BizHawk.Emulation/Consoles/Nintendo/NES/Boards/UxROM.cs
View File

@ -80,10 +80,10 @@ namespace BizHawk.Emulation.Consoles.Nintendo
else base.WritePPU(addr,value);
}
public override void SyncStateBinary(BinarySerializer ser)
public override void SyncState(Serializer ser)
{
base.SyncStateBinary(ser);
ser.Sync(ref prg);
base.SyncState(ser);
ser.Sync("prg", ref prg);
}
}
}

64
BizHawk.Emulation/Consoles/Nintendo/NES/NES.cs
View File

@ -221,7 +221,8 @@ namespace BizHawk.Emulation.Consoles.Nintendo
}
public int Frame { get; set; }
int _frame;
public int Frame { get { return _frame; } set { _frame = value; } }
public bool DeterministicEmulation { get { return true; } set { } }
@ -482,31 +483,23 @@ namespace BizHawk.Emulation.Consoles.Nintendo
}
}
public void SaveStateText(TextWriter writer)
void SyncState(Serializer ser)
{
writer.WriteLine("[NES]");
byte[] lol = SaveStateBinary();
writer.WriteLine("blob {0}", Util.BytesToHexString(lol));
writer.WriteLine("Frame {0}", Frame);
writer.WriteLine("[/NES]");
}
public void LoadStateText(TextReader reader)
{
byte[] blob = null;
while (true)
{
string[] args = reader.ReadLine().Split(' ');
if (args[0] == "blob")
blob = Util.HexStringToBytes(args[1]);
else if (args[0] == "Frame")
Frame = int.Parse(args[1]);
else if (args[0] == "[/NES]") break;
}
if (blob == null) throw new ArgumentException();
LoadStateBinary(new BinaryReader(new MemoryStream(blob)));
ser.BeginSection("NES");
ser.Sync("Frame", ref _frame);
cpu.SyncState(ser);
ser.Sync("ram", ref ram, false);
ser.Sync("CIRAM", ref CIRAM, false);
ser.Sync("cpu_accumulate", ref cpu_accumulate);
board.SyncState(ser);
ppu.SyncState(ser);
ser.EndSection();
}
public void SaveStateText(TextWriter writer) { SyncState(Serializer.CreateTextWriter(writer)); }
public void LoadStateText(TextReader reader) { SyncState(Serializer.CreateTextReader(reader)); }
public void SaveStateBinary(BinaryWriter bw) { SyncState(Serializer.CreateBinaryWriter(bw)); }
public void LoadStateBinary(BinaryReader br) { SyncState(Serializer.CreateBinaryReader(br)); }
public byte[] SaveStateBinary()
{
@ -516,31 +509,6 @@ namespace BizHawk.Emulation.Consoles.Nintendo
bw.Flush();
return ms.ToArray();
}
public void SaveStateBinary(BinaryWriter bw)
{
bw.Write(Frame);
cpu.SaveStateBinary(bw);
Util.WriteByteBuffer(bw, ram);
Util.WriteByteBuffer(bw, CIRAM);
bw.Write(cpu_accumulate);
board.SyncStateBinary(BinarySerializer.CreateWriter(bw));
ppu.SaveStateBinary(bw);
bw.Flush();
}
public void LoadStateBinary(BinaryReader br)
{
Frame = br.ReadInt32();
cpu.LoadStateBinary(br);
ram = Util.ReadByteBuffer(br, false);
CIRAM = Util.ReadByteBuffer(br, false);
cpu_accumulate = br.ReadInt32();
board.SyncStateBinary(BinarySerializer.CreateReader(br));
ppu.LoadStateBinary(br);
}
}
}

54
BizHawk.Emulation/Consoles/Nintendo/NES/PPU.cs
View File

@ -53,42 +53,28 @@ namespace BizHawk.Emulation.Consoles.Nintendo
int ppudead; //measured in frames
bool idleSynch;
public void SaveStateBinary(BinaryWriter bw)
public void SyncState(Serializer ser)
{
bw.Write(ppudead);
bw.Write(idleSynch);
bw.Write((bool)Reg2002_objoverflow);
bw.Write((bool)Reg2002_objhit);
bw.Write((bool)Reg2002_vblank_active);
bw.Write(PPUGenLatch);
bw.Write(reg_2000.Value);
bw.Write(reg_2001.Value);
bw.Write(reg_2003);
Util.WriteByteBuffer(bw, OAM);
Util.WriteByteBuffer(bw, PALRAM);
bw.Write(vtoggle);
bw.Write(VRAMBuffer);
ppur.SaveStateBinary(bw);
bw.Write(xbuf);
}
ser.Sync("ppudead", ref ppudead);
ser.Sync("idleSynch", ref idleSynch);
ser.Sync("Reg2002_objoverflow", ref Reg2002_objoverflow);
ser.Sync("Reg2002_objhit", ref Reg2002_objhit);
ser.Sync("Reg2002_vblank_active", ref Reg2002_vblank_active);
ser.Sync("PPUGenLatch", ref PPUGenLatch);
ser.Sync("reg_2003", ref reg_2003);
ser.Sync("OAM", ref OAM, false);
ser.Sync("PALRAM", ref PALRAM, false);
ser.Sync("vtoggle", ref vtoggle);
ser.Sync("VRAMBuffer", ref VRAMBuffer);
ppur.SyncState(ser);
public void LoadStateBinary(BinaryReader br)
{
ppudead = br.ReadInt32();
idleSynch = br.ReadBoolean();
Reg2002_objoverflow = br.ReadBit();
Reg2002_objhit = br.ReadBit();
Reg2002_vblank_active = br.ReadBit();
PPUGenLatch = br.ReadByte();
reg_2000.Value = br.ReadByte();
reg_2001.Value = br.ReadByte();
reg_2003 = br.ReadByte();
OAM = Util.ReadByteBuffer(br,false);
PALRAM = Util.ReadByteBuffer(br, false);
vtoggle = br.ReadBoolean();
VRAMBuffer = br.ReadByte();
ppur.LoadStateBinary(br);
xbuf = br.ReadShorts(xbuf.Length);
if(ser.IsText)
ser.Sync("xbuf", ref xbuf, false);
byte temp;
temp = reg_2000.Value; ser.Sync("reg_2000.Value", ref temp); reg_2000.Value = temp;
temp = reg_2001.Value; ser.Sync("reg_2001.Value", ref temp); reg_2001.Value = temp;
}
public void Reset()

48
BizHawk.Emulation/Consoles/Nintendo/NES/PPU.regs.cs
View File

@ -74,40 +74,22 @@ namespace BizHawk.Emulation.Consoles.Nintendo
reset();
}
public void SaveStateBinary(BinaryWriter bw)
public void SyncState(Serializer ser)
{
bw.Write(fv);
bw.Write(v);
bw.Write(h);
bw.Write(vt);
bw.Write(ht);
bw.Write(_fv);
bw.Write(_v);
bw.Write(_h);
bw.Write(_vt);
bw.Write(_ht);
bw.Write(fh);
bw.Write(status.cycle);
bw.Write(status.end_cycle);
bw.Write(status.sl);
}
public void LoadStateBinary(BinaryReader br)
{
fv = br.ReadInt32();
v = br.ReadInt32();
h = br.ReadInt32();
vt = br.ReadInt32();
ht = br.ReadInt32();
_fv = br.ReadInt32();
_v = br.ReadInt32();
_h = br.ReadInt32();
_vt = br.ReadInt32();
_ht = br.ReadInt32();
fh = br.ReadInt32();
status.cycle = br.ReadInt32();
status.end_cycle = br.ReadInt32();
status.sl = br.ReadInt32();
ser.Sync("fv", ref fv);
ser.Sync("v", ref v);
ser.Sync("h", ref h);
ser.Sync("vt", ref vt);
ser.Sync("ht", ref ht);
ser.Sync("_fv", ref _fv);
ser.Sync("_v", ref _v);
ser.Sync("_h", ref _h);
ser.Sync("_vt", ref _vt);
ser.Sync("_ht", ref _ht);
ser.Sync("fh", ref fh);
ser.Sync("status.cycle", ref status.cycle);
ser.Sync("status.end_cycle", ref status.end_cycle);
ser.Sync("status.sl", ref status.sl);
}
//normal clocked regs. as the game can interfere with these at any time, they need to be savestated

280
BizHawk.Emulation/Util.cs
View File

@ -306,7 +306,7 @@ namespace BizHawk
}
//these don't work??? they dont get chosen by compiler
public static void Write(this BinaryWriter bw, Bit bit) { bw.Write((bool)bit); }
public static void WriteBit(this BinaryWriter bw, Bit bit) { bw.Write((bool)bit); }
public static Bit ReadBit(this BinaryReader br) { return br.ReadBoolean(); }
}
@ -420,7 +420,29 @@ namespace BizHawk
}
}
//could be extension method
public static short[] ByteBufferToShortBuffer(byte[] buf)
{
int num = buf.Length/2;
short[] ret = new short[num];
for (int i = 0; i < num; i++)
{
ret[i] =(short)(buf[i * 2] | (buf[i * 2 + 1] << 8));
}
return ret;
}
public static byte[] ShortBufferToByteBuffer(short[] buf)
{
int num = buf.Length;
byte[] ret = new byte[num * 2];
for (int i = 0; i < num; i++)
{
ret[i * 2 + 0] = (byte)(buf[i] & 0xFF);
ret[i * 2 + 1] = (byte)((buf[i]>>8) & 0xFF);
}
return ret;
}
public static byte[] ReadByteBuffer(BinaryReader br, bool return_null)
{
int len = br.ReadInt32();
@ -515,89 +537,247 @@ namespace BizHawk
}
public class BinarySerializer
public class Serializer
{
BinaryReader br;
BinaryWriter bw;
TextReader tr;
TextWriter tw;
public BinaryReader BinaryReader { get { return br; } }
public BinaryWriter BinaryWriter { get { return bw; } }
public BinarySerializer() { }
public BinarySerializer(BinaryWriter _bw) { StartWrite(_bw); }
public BinarySerializer(BinaryReader _br) { StartRead(_br); }
public void StartWrite(BinaryWriter _bw) { this.bw = _bw; }
public void StartRead(BinaryReader _br) { this.br = _br; }
public static BinarySerializer CreateWriter(BinaryWriter _bw) { return new BinarySerializer(_bw); }
public static BinarySerializer CreateReader(BinaryReader _br) { return new BinarySerializer(_br); }
public TextReader TextReader { get { return tr; } }
public TextWriter TextWriter { get { return tw; } }
public Serializer() { }
public Serializer(BinaryWriter _bw) { StartWrite(_bw); }
public Serializer(BinaryReader _br) { StartRead(_br); }
public Serializer(TextWriter _tw) { StartWrite(_tw); }
public Serializer(TextReader _tr) { StartRead(_tr); }
public void StartWrite(BinaryWriter _bw) { this.bw = _bw; isReader = false; }
public void StartRead(BinaryReader _br) { this.br = _br; isReader = true; }
public void StartWrite(TextWriter _tw) { this.tw = _tw; isReader = false; isText = true; }
public void StartRead(TextReader _tr) { this.tr = _tr; isReader = true; isText = true; }
public static Serializer CreateBinaryWriter(BinaryWriter _bw) { return new Serializer(_bw); }
public static Serializer CreateBinaryReader(BinaryReader _br) { return new Serializer(_br); }
public static Serializer CreateTextWriter(TextWriter _tw) { return new Serializer(_tw); }
public static Serializer CreateTextReader(TextReader _tr) { return new Serializer(_tr); }
public bool IsReader { get { return br != null; } }
public bool IsWriter { get { return bw != null; } }
public bool IsReader { get { return isReader; } }
public bool IsWriter { get { return !IsReader; } }
public bool IsText { get { return isText; } }
bool isText;
bool isReader;
public unsafe void SyncEnum<T>(ref T val) where T : struct
Stack<string> sections = new Stack<string>();
public void BeginSection(string name)
{
sections.Push(name);
if (IsText)
if (IsWriter) { tw.WriteLine("[{0}]", name);}
else { tr.ReadLine(); }
}
public void EndSection()
{
string name = sections.Pop();
if (IsText)
if (IsWriter) tw.WriteLine("[/{0}]", name);
else tr.ReadLine();
}
public unsafe void SyncEnum<T>(string name, ref T val) where T : struct
{
if (typeof(T).BaseType != typeof(System.Enum))
throw new InvalidOperationException();
if (IsReader) val = (T)Enum.ToObject(typeof(T), br.ReadInt32());
if(isText) SyncEnumText<T>(name, ref val);
else if (IsReader) val = (T)Enum.ToObject(typeof(T), br.ReadInt32());
else bw.Write(Convert.ToInt32(val));
}
public void Sync(ref byte[] val, bool use_null)
public unsafe void SyncEnumText<T>(string name, ref T val) where T : struct
{
if (IsReader) val = Util.ReadByteBuffer(br, use_null);
if (IsReader) val = (T)Enum.Parse(typeof(T), tr.ReadLine().Split(' ')[1]);
else tw.WriteLine("{0} {1}", name, val.ToString());
}
public void Sync(string name, ref byte[] val, bool use_null)
{
if (IsText) SyncText(name, ref val, use_null);
else if (IsReader) val = Util.ReadByteBuffer(br, use_null);
else Util.WriteByteBuffer(bw, val);
}
public void Sync(ref byte val)
public void SyncText(string name, ref byte[] val, bool use_null)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref ushort val)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref uint val)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref sbyte val)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref short val)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref int val)
{
if (IsReader) Read(ref val);
else Write(ref val);
}
public void Sync(ref bool val)
{
if (IsReader) Read(ref val);
else Write(ref val);
if (IsReader)
{
string[] parts = tr.ReadLine().Split(' ');
val = Util.HexStringToBytes(parts[1]);
if (val.Length == 0 && use_null) val = null;
}
else
{
byte[] temp = val;
if (temp == null) temp = new byte[0];
tw.WriteLine("{0} {1}", name, Util.BytesToHexString(temp));
}
}
public void Sync(string name, ref short[] val, bool use_null)
{
if (IsText) SyncText(name, ref val, use_null);
else if (IsReader)
{
val = Util.ByteBufferToShortBuffer(Util.ReadByteBuffer(br, false));
if (val == null && !use_null) val = new short[0];
}
else Util.WriteByteBuffer(bw, Util.ShortBufferToByteBuffer(val));
}
public void SyncText(string name, ref short[] val, bool use_null)
{
if (IsReader)
{
string[] parts = tr.ReadLine().Split(' ');
byte[] bytes = Util.HexStringToBytes(parts[1]);
val = Util.ByteBufferToShortBuffer(bytes);
if (val.Length == 0 && use_null) val = null;
}
else
{
short[] temp = val;
if (temp == null) temp = new short[0];
tw.WriteLine("{0} {1}", name, Util.BytesToHexString(Util.ShortBufferToByteBuffer(temp)));
}
}
public void Sync(string name, ref Bit val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
public void SyncText(string name, ref Bit val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref byte val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref byte val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref ushort val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref ushort val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref uint val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref uint val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref sbyte val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref sbyte val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref short val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref short val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref int val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref int val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
public void Sync(string name, ref bool val)
{
if (IsText) SyncText(name, ref val);
else if (IsReader) Read(ref val);
else Write(ref val);
}
void SyncText(string name, ref bool val)
{
if (IsReader) ReadText(name, ref val);
else WriteText(name, ref val);
}
void Read(ref Bit val) { val = br.ReadBit(); }
void Write(ref Bit val) { bw.WriteBit(val); }
void ReadText(string name, ref Bit val) { val = (Bit)int.Parse(tr.ReadLine().Split(' ')[1]); }
void WriteText(string name, ref Bit val) { tw.WriteLine("{0} {1}", name, (int)val); }
void Read(ref byte val) { val = br.ReadByte(); }
void Write(ref byte val) { bw.Write(val); }
void ReadText(string name, ref byte val) { val = byte.Parse(tr.ReadLine().Split(' ')[1].Replace("0x", ""), NumberStyles.HexNumber); }
void WriteText(string name, ref byte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
void Read(ref ushort val) { val = br.ReadUInt16(); }
void Write(ref ushort val) { bw.Write(val); }
void ReadText(string name, ref ushort val) { val = ushort.Parse(tr.ReadLine().Split(' ')[1].Replace("0x", ""), NumberStyles.HexNumber); }
void WriteText(string name, ref ushort val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
void Read(ref uint val) { val = br.ReadUInt32(); }
void Write(ref uint val) { bw.Write(val); }
void ReadText(string name, ref uint val) { val = uint.Parse(tr.ReadLine().Split(' ')[1].Replace("0x", ""), NumberStyles.HexNumber); }
void WriteText(string name, ref uint val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
void Read(ref sbyte val) { val = br.ReadSByte(); }
void Write(ref sbyte val) { bw.Write(val); }
void ReadText(string name, ref sbyte val) { val = sbyte.Parse(tr.ReadLine().Split(' ')[1].Replace("0x", ""), NumberStyles.HexNumber); }
void WriteText(string name, ref sbyte val) { tw.WriteLine("{0} 0x{1:X2}", name, val); }
void Read(ref short val) { val = br.ReadInt16(); }
void Write(ref short val) { bw.Write(val); }
void ReadText(string name, ref short val) { val = short.Parse(tr.ReadLine().Split(' ')[1].Replace("0x", ""), NumberStyles.HexNumber); }
void WriteText(string name, ref short val) { tw.WriteLine("{0} 0x{1:X4}", name, val); }
void Read(ref int val) { val = br.ReadInt32(); }
void Write(ref int val) { bw.Write(val); }
void ReadText(string name, ref int val) { val = int.Parse(tr.ReadLine().Split(' ')[1].Replace("0x",""), NumberStyles.HexNumber); }
void WriteText(string name, ref int val) { tw.WriteLine("{0} 0x{1:X8}", name, val); }
void Read(ref bool val) { val = br.ReadBoolean(); }
void Write(ref bool val) { bw.Write(val); }
void ReadText(string name, ref bool val) { val = bool.Parse(tr.ReadLine().Split(' ')[1]); }
void WriteText(string name, ref bool val) { tw.WriteLine("{0} {1}", name, val); }
}