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 IRQ;
public bool NMI; public bool NMI;
public void SaveStateText(TextWriter writer) public void SyncState(Serializer ser)
{ {
writer.WriteLine("[MOS6502]"); ser.BeginSection("MOS6502");
writer.WriteLine("A {0:X2}", A); ser.Sync("A", ref A);
writer.WriteLine("X {0:X2}", X); ser.Sync("X", ref X);
writer.WriteLine("Y {0:X2}", Y); ser.Sync("Y", ref Y);
writer.WriteLine("P {0:X2}", P); ser.Sync("P", ref P);
writer.WriteLine("PC {0:X4}", PC); ser.Sync("PC", ref PC);
writer.WriteLine("S {0:X2}", S); ser.Sync("S", ref S);
writer.WriteLine("NMI {0}", NMI); ser.Sync("NMI", ref NMI);
writer.WriteLine("IRQ {0}", IRQ); ser.Sync("IRQ", ref IRQ);
writer.WriteLine("TotalExecutedCycles {0}", TotalExecutedCycles); ser.Sync("TotalExecutedCycles", ref TotalExecutedCycles);
writer.WriteLine("PendingCycles {0}", PendingCycles); ser.Sync("PendingCycles", ref PendingCycles);
writer.WriteLine("[/MOS6502]\n"); ser.EndSection();
} }
public void LoadStateText(TextReader reader) public void SaveStateBinary(BinaryWriter writer) { SyncState(Serializer.CreateBinaryWriter(writer)); }
{ public void LoadStateBinary(BinaryReader reader) { SyncState(Serializer.CreateBinaryReader(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)); }
// ==== End State ==== // ==== 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[] VRAM { get; set; }
byte[] ROM { get; set; } byte[] ROM { get; set; }
byte[] VROM { 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 CartInfo Cart { get { return NES.cart; } }
public NES NES { get; set; } public NES NES { get; set; }
public virtual void SyncStateBinary(BinarySerializer ser) public virtual void SyncState(Serializer ser)
{ {
ser.Sync(ref vram,true); ser.Sync("vram", ref vram, true);
ser.Sync(ref wram,true); ser.Sync("wram", ref wram, true);
for (int i = 0; i < 4; i++) ser.Sync(ref mirroring[i]); 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); else base.WritePPU(addr,value);
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref prg); 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); else base.WritePPU(addr,value);
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref chr); 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); else return base.ReadPPU(addr);
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref chr); 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 "BANDAI-GNROM":
case "HVC-GNROM": case "HVC-GNROM":
case "NES-MHROM": //Super Mario Bros. / Duck Hunt 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; break;
default: default:
@ -67,11 +67,11 @@ namespace BizHawk.Emulation.Consoles.Nintendo
prg = (((value>>4) & 3) & prg_mask); prg = (((value>>4) & 3) & prg_mask);
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref chr); ser.Sync("chr", ref chr);
ser.Sync(ref prg); 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; chr = (value >> 4) & chr_mask;
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref chr); ser.Sync("chr", ref chr);
ser.Sync(ref prg); 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); 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; right_piece = (value >> 4) & 7 & chr_mask;
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref left_piece); ser.Sync("left_piece", ref left_piece);
ser.Sync(ref right_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. //well, lets leave it.
} }
public void SyncStateBinary(BinarySerializer ser) public void SyncState(Serializer ser)
{ {
ser.Sync(ref shift_count); ser.Sync("shift_count", ref shift_count);
ser.Sync(ref shift_val); ser.Sync("shift_val", ref shift_val);
ser.Sync(ref chr_mode); ser.Sync("chr_mode", ref chr_mode);
ser.Sync(ref prg_mode); ser.Sync("prg_mode", ref prg_mode);
ser.Sync(ref prg_slot); ser.Sync("prg_slot", ref prg_slot);
ser.Sync(ref chr_0); ser.Sync("chr_0", ref chr_0);
ser.Sync(ref chr_1); ser.Sync("chr_1", ref chr_1);
ser.Sync(ref wram_disable); ser.Sync("wram_disable", ref wram_disable);
ser.Sync(ref prg); ser.Sync("prg", ref prg);
ser.SyncEnum(ref mirror); ser.SyncEnum("mirror", ref mirror);
} }
public enum Rev 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); base.SyncState(ser);
mmc1.SyncStateBinary(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); else base.WritePPU(addr,value);
} }
public override void SyncStateBinary(BinarySerializer ser) public override void SyncState(Serializer ser)
{ {
base.SyncStateBinary(ser); base.SyncState(ser);
ser.Sync(ref prg); 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 { } } 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]"); ser.BeginSection("NES");
byte[] lol = SaveStateBinary(); ser.Sync("Frame", ref _frame);
writer.WriteLine("blob {0}", Util.BytesToHexString(lol)); cpu.SyncState(ser);
writer.WriteLine("Frame {0}", Frame); ser.Sync("ram", ref ram, false);
writer.WriteLine("[/NES]"); ser.Sync("CIRAM", ref CIRAM, false);
} ser.Sync("cpu_accumulate", ref cpu_accumulate);
board.SyncState(ser);
public void LoadStateText(TextReader reader) ppu.SyncState(ser);
{ ser.EndSection();
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)));
} }
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() public byte[] SaveStateBinary()
{ {
@ -516,31 +509,6 @@ namespace BizHawk.Emulation.Consoles.Nintendo
bw.Flush(); bw.Flush();
return ms.ToArray(); 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 int ppudead; //measured in frames
bool idleSynch; bool idleSynch;
public void SaveStateBinary(BinaryWriter bw) public void SyncState(Serializer ser)
{ {
bw.Write(ppudead); ser.Sync("ppudead", ref ppudead);
bw.Write(idleSynch); ser.Sync("idleSynch", ref idleSynch);
bw.Write((bool)Reg2002_objoverflow); ser.Sync("Reg2002_objoverflow", ref Reg2002_objoverflow);
bw.Write((bool)Reg2002_objhit); ser.Sync("Reg2002_objhit", ref Reg2002_objhit);
bw.Write((bool)Reg2002_vblank_active); ser.Sync("Reg2002_vblank_active", ref Reg2002_vblank_active);
bw.Write(PPUGenLatch); ser.Sync("PPUGenLatch", ref PPUGenLatch);
bw.Write(reg_2000.Value); ser.Sync("reg_2003", ref reg_2003);
bw.Write(reg_2001.Value); ser.Sync("OAM", ref OAM, false);
bw.Write(reg_2003); ser.Sync("PALRAM", ref PALRAM, false);
Util.WriteByteBuffer(bw, OAM); ser.Sync("vtoggle", ref vtoggle);
Util.WriteByteBuffer(bw, PALRAM); ser.Sync("VRAMBuffer", ref VRAMBuffer);
bw.Write(vtoggle); ppur.SyncState(ser);
bw.Write(VRAMBuffer);
ppur.SaveStateBinary(bw);
bw.Write(xbuf);
}
public void LoadStateBinary(BinaryReader br) if(ser.IsText)
{ ser.Sync("xbuf", ref xbuf, false);
ppudead = br.ReadInt32();
idleSynch = br.ReadBoolean(); byte temp;
Reg2002_objoverflow = br.ReadBit();
Reg2002_objhit = br.ReadBit(); temp = reg_2000.Value; ser.Sync("reg_2000.Value", ref temp); reg_2000.Value = temp;
Reg2002_vblank_active = br.ReadBit(); temp = reg_2001.Value; ser.Sync("reg_2001.Value", ref temp); reg_2001.Value = temp;
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);
} }
public void Reset() public void Reset()

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

@ -74,40 +74,22 @@ namespace BizHawk.Emulation.Consoles.Nintendo
reset(); reset();
} }
public void SaveStateBinary(BinaryWriter bw) public void SyncState(Serializer ser)
{ {
bw.Write(fv); ser.Sync("fv", ref fv);
bw.Write(v); ser.Sync("v", ref v);
bw.Write(h); ser.Sync("h", ref h);
bw.Write(vt); ser.Sync("vt", ref vt);
bw.Write(ht); ser.Sync("ht", ref ht);
bw.Write(_fv); ser.Sync("_fv", ref _fv);
bw.Write(_v); ser.Sync("_v", ref _v);
bw.Write(_h); ser.Sync("_h", ref _h);
bw.Write(_vt); ser.Sync("_vt", ref _vt);
bw.Write(_ht); ser.Sync("_ht", ref _ht);
bw.Write(fh); ser.Sync("fh", ref fh);
bw.Write(status.cycle); ser.Sync("status.cycle", ref status.cycle);
bw.Write(status.end_cycle); ser.Sync("status.end_cycle", ref status.end_cycle);
bw.Write(status.sl); ser.Sync("status.sl", ref 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();
} }
//normal clocked regs. as the game can interfere with these at any time, they need to be savestated //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 //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(); } 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) public static byte[] ReadByteBuffer(BinaryReader br, bool return_null)
{ {
int len = br.ReadInt32(); int len = br.ReadInt32();
@ -515,89 +537,247 @@ namespace BizHawk
} }
public class BinarySerializer public class Serializer
{ {
BinaryReader br; BinaryReader br;
BinaryWriter bw; BinaryWriter bw;
TextReader tr;
TextWriter tw;
public BinaryReader BinaryReader { get { return br; } } public BinaryReader BinaryReader { get { return br; } }
public BinaryWriter BinaryWriter { get { return bw; } } public BinaryWriter BinaryWriter { get { return bw; } }
public BinarySerializer() { } public TextReader TextReader { get { return tr; } }
public BinarySerializer(BinaryWriter _bw) { StartWrite(_bw); } public TextWriter TextWriter { get { return tw; } }
public BinarySerializer(BinaryReader _br) { StartRead(_br); } public Serializer() { }
public void StartWrite(BinaryWriter _bw) { this.bw = _bw; } public Serializer(BinaryWriter _bw) { StartWrite(_bw); }
public void StartRead(BinaryReader _br) { this.br = _br; } public Serializer(BinaryReader _br) { StartRead(_br); }
public static BinarySerializer CreateWriter(BinaryWriter _bw) { return new BinarySerializer(_bw); } public Serializer(TextWriter _tw) { StartWrite(_tw); }
public static BinarySerializer CreateReader(BinaryReader _br) { return new BinarySerializer(_br); } 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 IsReader { get { return isReader; } }
public bool IsWriter { get { return bw != null; } } 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)) if (typeof(T).BaseType != typeof(System.Enum))
throw new InvalidOperationException(); 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)); 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); else Util.WriteByteBuffer(bw, val);
} }
public void SyncText(string name, ref byte[] val, bool use_null)
public void Sync(ref byte val)
{ {
if (IsReader) Read(ref val); if (IsReader)
else Write(ref val); {
} string[] parts = tr.ReadLine().Split(' ');
public void Sync(ref ushort val) val = Util.HexStringToBytes(parts[1]);
{ if (val.Length == 0 && use_null) val = null;
if (IsReader) Read(ref val); }
else Write(ref val); else
} {
public void Sync(ref uint val) byte[] temp = val;
{ if (temp == null) temp = new byte[0];
if (IsReader) Read(ref val); tw.WriteLine("{0} {1}", name, Util.BytesToHexString(temp));
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);
} }
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 Read(ref byte val) { val = br.ReadByte(); }
void Write(ref byte val) { bw.Write(val); } 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 Read(ref ushort val) { val = br.ReadUInt16(); }
void Write(ref ushort val) { bw.Write(val); } 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 Read(ref uint val) { val = br.ReadUInt32(); }
void Write(ref uint val) { bw.Write(val); } 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 Read(ref sbyte val) { val = br.ReadSByte(); }
void Write(ref sbyte val) { bw.Write(val); } 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 Read(ref short val) { val = br.ReadInt16(); }
void Write(ref short val) { bw.Write(val); } 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 Read(ref int val) { val = br.ReadInt32(); }
void Write(ref int val) { bw.Write(val); } 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 Read(ref bool val) { val = br.ReadBoolean(); }
void Write(ref bool val) { bw.Write(val); } 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); }
} }